Source – Alkane 2:80428 — SUBFROST Explorer

src/tests/helpers.rs15,319 B

//! Test helpers for FIRE system tests
//! Based on subfrost-alkanes patterns
pub use crate::test_log;
pub use alkanes::indexer::index_block;
pub use alkanes::view;
pub use alkanes::view::simulate_parcel;
pub use alkanes_support::cellpack::Cellpack;
pub use alkanes_support::envelope::RawEnvelope;
pub use alkanes_support::id::AlkaneId;
pub use alkanes_support::response::ExtendedCallResponse;
pub use anyhow::Result;
pub use bitcoin::address::NetworkChecked;
pub use bitcoin::blockdata::transaction::OutPoint;
pub use bitcoin::{Address, Block, Transaction};
pub use bitcoin::{Amount, ScriptBuf, Sequence, TxIn, TxOut, Witness};
pub use metashrew_core::index_pointer::AtomicPointer;
pub use ordinals::{Etching, Rune, Runestone};
pub use protorune::message::MessageContextParcel;
pub use protorune::protostone::Protostones;
pub use protorune::test_helpers::{create_block_with_coinbase_tx, get_address, ADDRESS1};
pub use protorune_support::balance_sheet::BalanceSheet;
pub use protorune_support::protostone::{Protostone, ProtostoneEdict};
pub use std::str::FromStr;
/// Simulate a cellpack execution
pub fn simulate_cellpack(height: u64, cellpack: Cellpack) -> Result<(ExtendedCallResponse, u64)> {
let parcel = MessageContextParcel {
atomic: AtomicPointer::default(),
runes: vec![],
transaction: Transaction {
version: bitcoin::blockdata::transaction::Version::ONE,
input: vec![],
output: vec![],
lock_time: bitcoin::absolute::LockTime::ZERO,
},
block: create_block_with_coinbase_tx(height as u32),
height,
pointer: 0,
refund_pointer: 0,
calldata: cellpack.encipher(),
sheets: Box::<BalanceSheet<AtomicPointer>>::new(BalanceSheet::default()),
txindex: 0,
vout: 0,
runtime_balances: Box::<BalanceSheet<AtomicPointer>>::new(BalanceSheet::default()),
};
simulate_parcel(&parcel, u64::MAX)
}
/// Get a test address by name
pub fn get_test_address(name: &str) -> Address<NetworkChecked> {
match name {
"user" | "signer" | "musig" => {
Address::from_str("bcrt1p3sye33j0axg4f2zswtw6m5s3esguncs9g0jw5g46a3l8zsw5zjwqj3nw5s")
.expect("Valid address")
.assume_checked()
}
_ => panic!("Unknown test address name: {}", name),
}
}
pub use protorune_support::network::{set_network, NetworkParams};
/// Configure network parameters for regtest
pub fn configure_network() {
set_network(NetworkParams {
bech32_prefix: String::from("bcrt"),
p2pkh_prefix: 0x64,
p2sh_prefix: 0xc4,
});
}
/// Clear the test environment and set up initial state
pub fn clear_test_environment() {
metashrew_core::clear();
configure_network();
// Index empty blocks up to height 2
for height in 0..3 {
let block = create_block_with_coinbase_tx(height);
index_block(&block, height).expect("Failed to index empty block");
}
}
/// Get balance sheet for a specific outpoint
pub fn get_sheet_by_outpoint(outpoint: &OutPoint) -> Result<BalanceSheet<metashrew_core::index_pointer::IndexPointer>> {
use protorune::balance_sheet::load_sheet;
use protorune::tables::RuneTable;
use alkanes::message::AlkaneMessageContext;
use protorune::message::MessageContext;
use metashrew_support::index_pointer::KeyValuePointer;
use metashrew_support::utils::consensus_encode;
let ptr = RuneTable::for_protocol(AlkaneMessageContext::protocol_tag())
.OUTPOINT_TO_RUNES
.select(&consensus_encode(outpoint)?);
Ok(load_sheet(&ptr))
}
/// Get balance sheet for the last outpoint in a block
pub fn get_last_outpoint_sheet(test_block: &Block) -> Result<BalanceSheet<metashrew_core::index_pointer::IndexPointer>> {
let len = test_block.txdata.len();
get_sheet_for_outpoint(test_block, len - 1, 0)
}
/// Get balance sheet for a specific transaction output in a block
pub fn get_sheet_for_outpoint(
test_block: &Block,
tx_num: usize,
vout: u32,
) -> Result<BalanceSheet<metashrew_core::index_pointer::IndexPointer>> {
let outpoint = OutPoint {
txid: test_block.txdata[tx_num].compute_txid(),
vout,
};
get_sheet_by_outpoint(&outpoint)
}
/// Create a transaction with a single cellpack
pub fn create_cellpack_tx(cellpack: Cellpack, binary: Option<Vec<u8>>) -> Transaction {
create_multiple_cellpack_with_witness(
binary.map(|b| RawEnvelope::from(b).to_witness(true)).unwrap_or_else(Witness::new),
vec![cellpack],
false,
)
}
/// Create a transaction with multiple cellpacks
pub fn create_multiple_cellpack_with_witness(
witness: Witness,
cellpacks: Vec<Cellpack>,
etch: bool,
) -> Transaction {
// Create a TxIn with the provided witness (contains WASM for deployment)
let txin = TxIn {
previous_output: OutPoint::null(),
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness,
};
create_multiple_cellpack_with_witness_and_txins_edicts(cellpacks, vec![txin], etch, vec![])
}
/// Create a transaction with cellpacks and specific transaction inputs
pub fn create_multiple_cellpack_with_witness_and_in(
witness: Witness,
cellpacks: Vec<Cellpack>,
previous_output: OutPoint,
etch: bool,
) -> Transaction {
let txin = TxIn {
previous_output,
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness,
};
create_multiple_cellpack_with_witness_and_txins_edicts(cellpacks, vec![txin], etch, vec![])
}
/// Create transaction with cellpacks, txins, and edicts (full control)
pub fn create_multiple_cellpack_with_witness_and_txins_edicts(
cellpacks: Vec<Cellpack>,
txins: Vec<TxIn>,
etch: bool,
edicts: Vec<ProtostoneEdict>,
) -> Transaction {
let protocol_id = 1;
// Create protostones from cellpacks
let protostones: Vec<Protostone> = cellpacks
.into_iter()
.map(|cellpack| Protostone {
message: cellpack.encipher(),
pointer: Some(0),
refund: Some(0),
edicts: edicts.clone(),
from: None,
burn: None,
protocol_tag: protocol_id,
})
.collect();
// Create the runestone
let etching = if etch {
Some(Etching {
rune: Some(Rune(0)),
divisibility: Some(0),
premine: Some(21_000_000),
spacers: Some(0),
symbol: Some('X'),
terms: None,
turbo: false,
})
} else {
None
};
let runestone: ScriptBuf = (Runestone {
etching,
pointer: Some(0),
edicts: Vec::new(),
mint: None,
protocol: protostones.encipher().ok(),
})
.encipher();
// Create outputs
let address: Address<NetworkChecked> = get_address(&ADDRESS1().as_str());
let op_return = TxOut {
value: Amount::from_sat(0),
script_pubkey: runestone,
};
let recipient_output = TxOut {
value: Amount::from_sat(100_000_000),
script_pubkey: address.script_pubkey(),
};
// Create inputs - use provided or default
let inputs = if txins.is_empty() {
vec![TxIn {
previous_output: OutPoint::null(),
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness: Witness::new(),
}]
} else {
txins
};
Transaction {
version: bitcoin::blockdata::transaction::Version::ONE,
lock_time: bitcoin::absolute::LockTime::ZERO,
input: inputs,
output: vec![recipient_output, op_return],
}
}
/// Initialize with cellpack pairs (binary + cellpack)
pub fn init_with_multiple_cellpacks_with_tx(
binaries: Vec<Vec<u8>>,
cellpacks: Vec<Cellpack>,
) -> Block {
let block_height = 880_000;
let mut test_block = create_block_with_coinbase_tx(block_height);
let mut previous_out: Option<OutPoint> = None;
let mut txs = binaries
.into_iter()
.zip(cellpacks.into_iter())
.map(|(binary, cellpack)| {
let witness = if binary.is_empty() {
Witness::new()
} else {
RawEnvelope::from(binary).to_witness(true)
};
if let Some(previous_output) = previous_out {
let tx = create_multiple_cellpack_with_witness_and_in(
witness,
vec![cellpack],
previous_output,
false,
);
previous_out = Some(OutPoint {
txid: tx.compute_txid(),
vout: 0,
});
tx
} else {
let tx = create_multiple_cellpack_with_witness(witness, vec![cellpack], false);
previous_out = Some(OutPoint {
txid: tx.compute_txid(),
vout: 0,
});
tx
}
})
.collect::<Vec<Transaction>>();
test_block.txdata.append(&mut txs);
test_block
}
/// Create a block with a deployment transaction
pub fn create_deployment_block(
height: u32,
wasm_bytes: &[u8],
cellpack: Cellpack,
) -> Block {
let mut block = create_block_with_coinbase_tx(height);
let witness = RawEnvelope::from(wasm_bytes.to_vec()).to_witness(true);
let tx = create_multiple_cellpack_with_witness(witness, vec![cellpack], false);
block.txdata.push(tx);
block
}
/// Create a block with an operation transaction
pub fn create_operation_block(
height: u32,
cellpack: Cellpack,
input_outpoint: Option<OutPoint>,
) -> Block {
let mut block = create_block_with_coinbase_tx(height);
let tx = if let Some(outpoint) = input_outpoint {
create_multiple_cellpack_with_witness_and_in(
Witness::new(),
vec![cellpack],
outpoint,
false,
)
} else {
create_multiple_cellpack_with_witness(Witness::new(), vec![cellpack], false)
};
block.txdata.push(tx);
block
}
/// Debug: print balance sheet contents
pub fn debug_balance_sheet(_sheet: &BalanceSheet<metashrew_core::index_pointer::IndexPointer>, label: &str) {
test_log!("\n📊 Balance Sheet: {}", label);
test_log!(" (Use sheet.get_cached(&token_id.into()) to query specific tokens)");
}
/// Tracer for debugging contract execution
pub struct Tracer {
pub block_name: String,
pub max_vouts_to_check: u32,
}
impl Tracer {
pub fn new(block_name: &str) -> Self {
Self {
block_name: block_name.to_string(),
max_vouts_to_check: 15,
}
}
#[allow(dead_code)]
pub fn with_max_vouts(mut self, max_vouts: u32) -> Self {
self.max_vouts_to_check = max_vouts;
self
}
/// Index a block and trace all outputs
pub fn index_and_trace(&self, block: &Block, height: u32) -> Result<()> {
index_block(block, height)?;
test_log!("\n📊 Tracing {} (Block {})", self.block_name, height);
test_log!("==================================================");
for (tx_idx, tx) in block.txdata.iter().enumerate() {
self.trace_transaction(tx, tx_idx)?;
}
Ok(())
}
/// Trace a specific transaction
pub fn trace_transaction(&self, tx: &Transaction, tx_idx: usize) -> Result<()> {
let txid = tx.compute_txid();
test_log!("\n Transaction {}: {}", tx_idx, txid);
let mut found_traces = false;
for vout in 0..self.max_vouts_to_check {
let outpoint = OutPoint { txid, vout };
if let Ok(trace_data) = view::trace(&outpoint) {
if !trace_data.is_empty() {
found_traces = true;
decode_and_print_trace(&trace_data, vout);
}
}
}
if !found_traces {
test_log!(" No traces found for this transaction");
}
Ok(())
}
}
/// Decode and print trace data using AlkanesTrace protobuf
pub fn decode_and_print_trace(trace_data: &[u8], vout: u32) {
use alkanes_support::proto::alkanes::AlkanesTrace;
use alkanes_support::trace::Trace;
use prost::Message;
test_log!(" Output {}: {} bytes of trace data", vout, trace_data.len());
match AlkanesTrace::decode(trace_data) {
Ok(alkanes_trace) => {
let trace: Trace = alkanes_trace.into();
let trace_guard = trace.0.lock().unwrap();
for (i, op) in trace_guard.iter().enumerate() {
let op_str = format!("{:?}", op);
// Truncate long traces for readability
if op_str.len() > 200 {
test_log!(" [{}] {}...", i, &op_str[..200]);
} else {
test_log!(" [{}] {}", i, op_str);
}
}
}
Err(e) => {
test_log!(" Failed to decode trace: {}", e);
}
}
}
/// Trace a specific outpoint and return decoded trace operations
pub fn trace_outpoint(outpoint: &OutPoint) -> Result<Vec<String>> {
use alkanes_support::proto::alkanes::AlkanesTrace;
use alkanes_support::trace::Trace;
use prost::Message;
let trace_data = view::trace(outpoint)?;
if trace_data.is_empty() {
return Ok(vec![]);
}
let alkanes_trace = AlkanesTrace::decode(&*trace_data)?;
let trace: Trace = alkanes_trace.into();
let trace_guard = trace.0.lock().unwrap();
let ops: Vec<String> = trace_guard.iter().map(|op| format!("{:?}", op)).collect();
Ok(ops)
}
// Mainnet token constants
pub const DIESEL_ID: AlkaneId = AlkaneId { block: 2, tx: 0 };
pub const FR_BTC_ID: AlkaneId = AlkaneId { block: 32, tx: 0 };
pub const AMM_FACTORY_ID: AlkaneId = AlkaneId { block: 4, tx: 65522 };
// DIESEL/frBTC LP token (mainnet pool)
pub const DIESEL_FRBTC_LP_ID: AlkaneId = AlkaneId { block: 2, tx: 77087 };
// FIRE contract deployment IDs (using 0x100 range to avoid conflicts)
pub const FIRE_TOKEN_TX: u128 = 0x100;
pub const FIRE_STAKING_TX: u128 = 0x101;
pub const FIRE_TREASURY_TX: u128 = 0x102;
pub const FIRE_BONDING_TX: u128 = 0x103;
pub const FIRE_REDEMPTION_TX: u128 = 0x104;
pub const FIRE_DISTRIBUTOR_TX: u128 = 0x105;
/// Get FIRE token ID after deployment
pub fn fire_token_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_TOKEN_TX }
}
/// Get FIRE staking ID after deployment
pub fn fire_staking_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_STAKING_TX }
}
/// Get FIRE treasury ID after deployment
pub fn fire_treasury_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_TREASURY_TX }
}
/// Get FIRE bonding ID after deployment
pub fn fire_bonding_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_BONDING_TX }
}
/// Get FIRE redemption ID after deployment
pub fn fire_redemption_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_REDEMPTION_TX }
}
/// Get FIRE distributor ID after deployment
pub fn fire_distributor_id() -> AlkaneId {
AlkaneId { block: 4, tx: FIRE_DISTRIBUTOR_TX }
}
/// Get DIESEL/frBTC LP token ID (mainnet)
pub fn diesel_frbtc_lp_id() -> AlkaneId {
DIESEL_FRBTC_LP_ID
}

Verified Source