Verified Source

2:79421✓ Verified

Commitbf647d03491e

Match94.1%

Files53

The exact source a sandboxed build reproduced the on-chain wasm from – served from SUBFROST's verified-build database, since the origin repository is private.

Build & verification details

Reproduction recipestructural match

Every fixture below was reversed from the on-chain bytecode, then pinned in a sandboxed rebuild. Reproduced deterministically – the source genuinely compiles to this bytecode.

Toolchain

Build environment

HOME

/Users/misha

← embedded registry/git-checkout paths

CARGO_HOME

/Users/misha/.cargo

env

PROTOC=/usr/bin/protoc

env

CC_wasm32_unknown_unknown=Homebrew clang 20.1.7 (recipe origin 20.1.4)

env

AR_wasm32_unknown_unknown=llvm-ar

env

build dir = /Users/misha/fire

Git dependency

repo

kungfuflex/alkanes-rs

rev

550aea1a38c8b5299b8adc6df49d2e27569613eb

← fingerprint git_deps

source-id

bare (matches -C metadata → mono ordering)

src/tests/transaction_builder.rs4,688 B

//! Transaction builder for FIRE tests
//! Following the exact alkanes-rs pattern for handling token transfers
use alkanes_support::cellpack::Cellpack;
use alkanes_support::id::AlkaneId;
use bitcoin::{
address::NetworkChecked, Address, Amount, OutPoint, ScriptBuf, Sequence, Transaction, TxIn,
TxOut, Witness,
};
use bitcoin::blockdata::transaction::Version;
use ordinals::Runestone;
use protorune::test_helpers::{get_address, ADDRESS1};
use protorune_support::protostone::{Protostone, ProtostoneEdict};
use protorune::protostone::Protostones;
/// Builder for creating transactions with precise control over token flows
pub struct TransactionBuilder {
inputs: Vec<TxIn>,
cellpacks: Vec<Cellpack>,
edicts: Vec<ProtostoneEdict>,
}
impl Default for TransactionBuilder {
fn default() -> Self {
Self::new()
}
}
impl TransactionBuilder {
pub fn new() -> Self {
Self {
inputs: Vec::new(),
cellpacks: Vec::new(),
edicts: Vec::new(),
}
}
/// Add an input to spend (this is where tokens come FROM)
pub fn add_input(mut self, outpoint: OutPoint, witness: Witness) -> Self {
self.inputs.push(TxIn {
previous_output: outpoint,
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness,
});
self
}
/// Add a simple input with no witness
pub fn add_input_simple(self, outpoint: OutPoint) -> Self {
self.add_input(outpoint, Witness::new())
}
/// Add a cellpack (contract call)
pub fn add_cellpack(mut self, cellpack: Cellpack) -> Self {
self.cellpacks.push(cellpack);
self
}
/// Add an edict to send tokens from inputs to a specific output
pub fn add_edict(mut self, token_id: AlkaneId, amount: u128, output_idx: u32) -> Self {
use protorune_support::balance_sheet::ProtoruneRuneId;
self.edicts.push(ProtostoneEdict {
id: ProtoruneRuneId {
block: token_id.block,
tx: token_id.tx,
},
amount,
output: output_idx as u128,
});
self
}
/// Build the transaction
pub fn build(self) -> Transaction {
let protocol_id = 1;
// Create protostones from cellpacks
let protostones: Vec<Protostone> = self
.cellpacks
.into_iter()
.map(|cellpack| Protostone {
message: cellpack.encipher(),
pointer: Some(0),
refund: Some(0),
edicts: self.edicts.clone(),
from: None,
burn: None,
protocol_tag: protocol_id,
})
.collect();
// Create the runestone
let runestone: ScriptBuf = (Runestone {
etching: None,
pointer: Some(0),
edicts: Vec::new(),
mint: None,
protocol: protostones.encipher().ok(),
})
.encipher();
// OP_RETURN output with runestone
let op_return = TxOut {
value: Amount::from_sat(0),
script_pubkey: runestone,
};
// Output 0: where tokens go and where contract executes
let address: Address<NetworkChecked> = get_address(&ADDRESS1().as_str());
let output_0 = TxOut {
value: Amount::from_sat(100_000_000),
script_pubkey: address.script_pubkey(),
};
// Use provided inputs or create a default one
let inputs = if self.inputs.is_empty() {
vec![TxIn {
previous_output: OutPoint::null(),
script_sig: ScriptBuf::new(),
sequence: Sequence::MAX,
witness: Witness::new(),
}]
} else {
self.inputs
};
Transaction {
version: Version::ONE,
lock_time: bitcoin::absolute::LockTime::ZERO,
input: inputs,
output: vec![output_0, op_return],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tests::helpers::configure_network;
#[test]
fn test_builder_creates_transaction() {
configure_network();
let tx = TransactionBuilder::new()
.add_input_simple(OutPoint::null())
.add_edict(AlkaneId { block: 2, tx: 0 }, 1000, 0)
.add_cellpack(Cellpack {
target: AlkaneId { block: 4, tx: 1 },
inputs: vec![1, 2, 3],
})
.build();
assert_eq!(tx.input.len(), 1);
assert_eq!(tx.output.len(), 2); // output 0 + OP_RETURN
}
}