Struct bdk_chain::bitcoin::MerkleBlock

pub struct MerkleBlock {
    pub header: Header,
    pub txn: PartialMerkleTree,
}

Data structure that represents a block header paired to a partial merkle tree.

NOTE: This assumes that the given Block has at least 1 transaction. If the Block has 0 txs, it will hit an assertion.

Fields

header: Header

The block header

txn: PartialMerkleTree

Transactions making up a partial merkle tree

Implementations

impl MerkleBlock

pub fn from_block_with_predicate<F>( block: &Block, match_txids: F ) -> MerkleBlock

where F: Fn(&Txid) -> bool,

Create a MerkleBlock from a block, that contains proofs for specific txids.

The block is a full block containing the header and transactions and match_txids is a function that returns true for the ids that should be included in the partial merkle tree.

Examples

use bitcoin::hash_types::Txid;
use bitcoin::hex::FromHex;
use bitcoin::{Block, MerkleBlock};

// Block 80000
let block_bytes = Vec::from_hex("01000000ba8b9cda965dd8e536670f9ddec10e53aab14b20bacad2\
    7b9137190000000000190760b278fe7b8565fda3b968b918d5fd997f993b23674c0af3b6fde300b38f33\
    a5914ce6ed5b1b01e32f5702010000000100000000000000000000000000000000000000000000000000\
    00000000000000ffffffff0704e6ed5b1b014effffffff0100f2052a01000000434104b68a50eaa0287e\
    ff855189f949c1c6e5f58b37c88231373d8a59809cbae83059cc6469d65c665ccfd1cfeb75c6e8e19413\
    bba7fbff9bc762419a76d87b16086eac000000000100000001a6b97044d03da79c005b20ea9c0e1a6d9d\
    c12d9f7b91a5911c9030a439eed8f5000000004948304502206e21798a42fae0e854281abd38bacd1aee\
    d3ee3738d9e1446618c4571d1090db022100e2ac980643b0b82c0e88ffdfec6b64e3e6ba35e7ba5fdd7d\
    5d6cc8d25c6b241501ffffffff0100f2052a010000001976a914404371705fa9bd789a2fcd52d2c580b6\
    5d35549d88ac00000000").unwrap();
let block: Block = bitcoin::consensus::deserialize(&block_bytes).unwrap();

// Create a merkle block containing a single transaction
let txid = "5a4ebf66822b0b2d56bd9dc64ece0bc38ee7844a23ff1d7320a88c5fdb2ad3e2".parse::<Txid>().unwrap();
let match_txids: Vec<Txid> = vec![txid].into_iter().collect();
let mb = MerkleBlock::from_block_with_predicate(&block, |t| match_txids.contains(t));

// Authenticate and extract matched transaction ids
let mut matches: Vec<Txid> = vec![];
let mut index: Vec<u32> = vec![];
assert!(mb.extract_matches(&mut matches, &mut index).is_ok());
assert_eq!(txid, matches[0]);

pub fn from_header_txids_with_predicate<F>( header: &Header, block_txids: &[Txid], match_txids: F ) -> MerkleBlock

where F: Fn(&Txid) -> bool,

Create a MerkleBlock from the block’s header and txids, that contain proofs for specific txids.

The header is the block header, block_txids is the full list of txids included in the block and match_txids is a function that returns true for the ids that should be included in the partial merkle tree.

pub fn extract_matches( &self, matches: &mut Vec<Txid>, indexes: &mut Vec<u32> ) -> Result<(), MerkleBlockError>

Extract the matching txid’s represented by this partial merkle tree and their respective indices within the partial tree. returns Ok(()) on success, or error in case of failure

Trait Implementations

impl Clone for MerkleBlock

fn clone(&self) -> MerkleBlock

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MerkleBlock

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Decodable for MerkleBlock

fn consensus_decode<R>(r: &mut R) -> Result<MerkleBlock, Error>

where R: Read + ?Sized,

Decode an object with a well-defined format.

fn consensus_decode_from_finite_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + ?Sized,

Decode Self from a size-limited reader.

impl Encodable for MerkleBlock

fn consensus_encode<W>(&self, w: &mut W) -> Result<usize, Error>

where W: Write + ?Sized,

Encodes an object with a well-defined format.

impl PartialEq for MerkleBlock

fn eq(&self, other: &MerkleBlock) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for MerkleBlock

impl StructuralPartialEq for MerkleBlock