kylefang/stacks-puppet-node
1
0
Fork 0
mirror of https://github.com/alexgo-io/stacks-puppet-node.git synced 2026-04-23 19:31:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

added burnchain_op field to transaction event payload + test

Browse Source
This commit is contained in:
Pavitthra Pandurangan
2023-01-13 14:45:29 -05:00
parent c169579571
commit 57436f0dcb
4 changed files with 55 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/chainstate/stacks/db/blocks.rs
View File

@@ -4920,23 +4920,23 @@ impl StacksChainState {
txid,
burn_header_hash,
..
} = stack_stx_op;
} = &stack_stx_op;
let result = clarity_tx.connection().as_transaction(|tx| {
tx.run_contract_call(
&sender.into(),
&sender.clone().into(),
None,
&boot_code_id(active_pox_contract, mainnet),
"stack-stx",
&[
Value::UInt(stacked_ustx),
Value::UInt(*stacked_ustx),
// this .expect() should be unreachable since we coerce the hash mode when
// we parse the StackStxOp from a burnchain transaction
reward_addr
.as_clarity_tuple()
.expect("FATAL: stack-stx operation has no hash mode")
.into(),
Value::UInt(u128::from(block_height)),
Value::UInt(u128::from(num_cycles)),
Value::UInt(u128::from(*block_height)),
Value::UInt(u128::from(*num_cycles)),
],
|_, _| false,
)
@@ -4958,7 +4958,7 @@ impl StacksChainState {
.expect("BUG: cost declined between executions");
let receipt = StacksTransactionReceipt {
transaction: TransactionOrigin::Burn(txid),
transaction: TransactionOrigin::Burn(BlockstackOperationType::StackStx(stack_stx_op)),
events,
result: value,
post_condition_aborted: false,
@@ -5009,20 +5009,20 @@ impl StacksChainState {
burn_header_hash,
memo,
..
} = transfer_stx_op;
} = &transfer_stx_op;
let result = clarity_tx.connection().as_transaction(|tx| {
tx.run_stx_transfer(
&sender.into(),
&recipient.into(),
transfered_ustx,
&BuffData { data: memo },
&sender.clone().into(),
&recipient.clone().into(),
*transfered_ustx,
&BuffData { data: memo.clone() },
)
});
match result {
Ok((value, _, events)) => {
debug!("Processed TransferStx burnchain op"; "transfered_ustx" => transfered_ustx, "sender" => %sender, "recipient" => %recipient, "txid" => %txid);
Some(StacksTransactionReceipt {
transaction: TransactionOrigin::Burn(txid),
transaction: TransactionOrigin::Burn(BlockstackOperationType::TransferStx(transfer_stx_op)),
events,
result: value,
post_condition_aborted: false,
@@ -5071,7 +5071,7 @@ impl StacksChainState {
txid,
burn_header_hash,
..
} = delegate_stx_op;
} = &delegate_stx_op;
let reward_addr_val = if let Some((_, addr)) = &reward_addr {
// this .expect() should be unreachable since we coerce the hash mode when
// we parse the DelegateStxOp from a burnchain transaction
@@ -5087,20 +5087,20 @@ impl StacksChainState {
};
let until_burn_height_val = if let Some(height) = until_burn_height {
Value::some(Value::UInt(u128::from(height)))
Value::some(Value::UInt(u128::from(*height)))
.expect("FATAL: construction of an optional uint Clarity value should succeed.")
} else {
Value::none()
};
let result = clarity_tx.connection().as_transaction(|tx| {
tx.run_contract_call(
&sender.into(),
&sender.clone().into(),
None,
&boot_code_id(active_pox_contract, mainnet),
"delegate-stx",
&[
Value::UInt(delegated_ustx),
Value::Principal(delegate_to.into()),
Value::UInt(*delegated_ustx),
Value::Principal(delegate_to.clone().into()),
until_burn_height_val,
reward_addr_val,
],
@@ -5126,7 +5126,7 @@ impl StacksChainState {
.expect("BUG: cost declined between executions");
let receipt = StacksTransactionReceipt {
transaction: TransactionOrigin::Burn(txid),
transaction: TransactionOrigin::Burn(BlockstackOperationType::DelegateStx(delegate_stx_op)),
events,
result: value,
post_condition_aborted: false,

7
src/chainstate/stacks/events.rs
View File

@@ -11,11 +11,12 @@ use clarity::vm::types::{
};
pub use clarity::vm::events::StacksTransactionEvent;
use crate::chainstate::burn::operations::BlockstackOperationType;
#[derive(Debug, Clone, PartialEq)]
pub enum TransactionOrigin {
Stacks(StacksTransaction),
Burn(Txid),
Burn(BlockstackOperationType),
}
impl From<StacksTransaction> for TransactionOrigin {
@@ -27,7 +28,7 @@ impl From<StacksTransaction> for TransactionOrigin {
impl TransactionOrigin {
pub fn txid(&self) -> Txid {
match self {
TransactionOrigin::Burn(txid) => txid.clone(),
TransactionOrigin::Burn(op) => op.txid(),
TransactionOrigin::Stacks(tx) => tx.txid(),
}
}
@@ -35,7 +36,7 @@ impl TransactionOrigin {
/// a database
pub fn serialize_to_dbstring(&self) -> String {
match self {
TransactionOrigin::Burn(txid) => format!("BTC({})", txid),
TransactionOrigin::Burn(op) => format!("BTC({})", op.txid()),
TransactionOrigin::Stacks(tx) => to_hex(&tx.serialize_to_vec()),
}
}

11
testnet/stacks-node/src/event_dispatcher.rs
View File

@@ -46,6 +46,7 @@ struct ReceiptPayloadInfo<'a> {
raw_result: String,
raw_tx: String,
contract_interface_json: serde_json::Value,
burnchain_op_json: serde_json::Value,
}
const STATUS_RESP_TRUE: &str = "success";
@@ -214,12 +215,14 @@ impl EventObserver {
}
};
let (txid, raw_tx) = match tx {
TransactionOrigin::Burn(txid) => (txid.to_string(), "00".to_string()),
let (txid, raw_tx, burnchain_op) = match tx {
TransactionOrigin::Burn(op) => (
op.txid().to_string(), "00".to_string(), json!(op.clone())
),
TransactionOrigin::Stacks(ref tx) => {
let txid = tx.txid().to_string();
let bytes = tx.serialize_to_vec();
(txid, bytes_to_hex(&bytes))
(txid, bytes_to_hex(&bytes), json!(null))
}
};
@@ -239,6 +242,7 @@ impl EventObserver {
raw_result,
raw_tx,
contract_interface_json,
burnchain_op_json: burnchain_op,
}
}
@@ -256,6 +260,7 @@ impl EventObserver {
"raw_result": format!("0x{}", &receipt_payload_info.raw_result),
"raw_tx": format!("0x{}", &receipt_payload_info.raw_tx),
"contract_abi": receipt_payload_info.contract_interface_json,
"burnchain_op": receipt_payload_info.burnchain_op_json,
"execution_cost": receipt.execution_cost,
"microblock_sequence": receipt.microblock_header.as_ref().map(|x| x.sequence),
"microblock_hash": receipt.microblock_header.as_ref().map(|x| format!("0x{}", x.block_hash())),

25
testnet/stacks-node/src/tests/neon_integrations.rs
View File

@@ -1505,6 +1505,12 @@ fn stx_transfer_btc_integration_test() {
let (mut conf, _miner_account) = neon_integration_test_conf();
test_observer::spawn();
conf.events_observers.push(EventObserverConfig {
endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
events_keys: vec![EventKeyType::AnyEvent],
});
conf.initial_balances.push(InitialBalance {
address: spender_addr.clone(),
amount: 100300,
@@ -1547,6 +1553,8 @@ fn stx_transfer_btc_integration_test() {
// second block will be the first mined Stacks block
next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
test_observer::clear();
// let's query the spender's account:
assert_eq!(get_balance(&http_origin, &spender_addr), 100300);
@@ -1686,6 +1694,23 @@ fn stx_transfer_btc_integration_test() {
assert_eq!(get_balance(&http_origin, &recipient_addr), 200_000);
assert_eq!(get_balance(&http_origin, &spender_2_addr), 300);
let mut found_btc_tx = false;
let blocks = test_observer::get_blocks();
for block in blocks {
let transactions = block.get("transactions").unwrap().as_array().unwrap();
for tx in transactions.iter() {
let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
if raw_tx == "0x00" {
let burnchain_op = tx.get("burnchain_op").unwrap().as_object().unwrap();
if !burnchain_op.contains_key("TransferStx") {
panic!("unexpected btc transaction type");
}
found_btc_tx = true;
}
}
}
assert!(found_btc_tx);
channel.stop_chains_coordinator();
}