Struct Root

pub struct Root(pub [u8; 32]);

The root of the Bitcoin-inherited transaction Merkle tree, binding the block header to the transactions in the block.

Note: for V5-onward transactions it does not bind to authorizing data (signature and proofs) which makes it non-malleable ZIP-244.

Note that because of a flaw in Bitcoin’s design, the merkle_root does not always precisely bind the contents of the block (CVE-2012-2459). It is sometimes possible for an attacker to create multiple distinct sets of transactions with the same Merkle root, although only one set will be valid.

Malleability

The Bitcoin source code contains the following note:

WARNING! If you’re reading this because you’re learning about crypto and/or designing a new system that will use merkle trees, keep in mind that the following merkle tree algorithm has a serious flaw related to duplicate txids, resulting in a vulnerability (CVE-2012-2459). The reason is that if the number of hashes in the list at a given time is odd, the last one is duplicated before computing the next level (which is unusual in Merkle trees). This results in certain sequences of transactions leading to the same merkle root. For example, these two trees:

             A               A
           /  \            /   \
         B     C         B       C
        / \    |        / \     / \
       D   E   F       D   E   F   F
      / \ / \ / \     / \ / \ / \ / \
      1 2 3 4 5 6     1 2 3 4 5 6 5 6

for transaction lists [1,2,3,4,5,6] and [1,2,3,4,5,6,5,6] (where 5 and 6 are repeated) result in the same root hash A (because the hash of both of (F) and (F,F) is C).

The vulnerability results from being able to send a block with such a transaction list, with the same merkle root, and the same block hash as the original without duplication, resulting in failed validation. If the receiving node proceeds to mark that block as permanently invalid however, it will fail to accept further unmodified (and thus potentially valid) versions of the same block. We defend against this by detecting the case where we would hash two identical hashes at the end of the list together, and treating that identically to the block having an invalid merkle root. Assuming no double-SHA256 collisions, this will detect all known ways of changing the transactions without affecting the merkle root.

This vulnerability does not apply to Zebra, because it does not store invalid data on disk, and because it does not permanently fail blocks or use an aggressive anti-DoS mechanism.

Tuple Fields

0: [u8; 32]

Implementations

impl Root

pub fn bytes_in_display_order(&self) -> [u8; 32]

Return the hash bytes in big-endian byte-order suitable for printing out byte by byte.

Zebra displays transaction and block hashes in big-endian byte-order, following the u256 convention set by Bitcoin and zcashd.

pub fn from_bytes_in_display_order(bytes_in_display_order: &[u8; 32]) -> Root

Convert bytes in big-endian byte-order into a merkle::Root.

Zebra displays transaction and block hashes in big-endian byte-order, following the u256 convention set by Bitcoin and zcashd.

Trait Implementations

impl Arbitrary for Root

type Parameters = <[u8; 32] as Arbitrary>::Parameters

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<[u8; 32] as Arbitrary>::Strategy, fn(_: [u8; 32]) -> Root>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl Clone for Root

fn clone(&self) -> Root

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Root

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

Formats the value using the given formatter.

impl Default for Root

fn default() -> Root

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Root

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<[u8; 32]> for Root

fn from(hash: [u8; 32]) -> Self

Converts to this type from the input type.

impl From<Root> for [u8; 32]

fn from(hash: Root) -> Self

Converts to this type from the input type.

impl FromHex for Root

type Error = <[u8; 32] as FromHex>::Error

fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error>

Creates an instance of type Self from the given hex string, or fails with a custom error type.

impl FromIterator<Hash> for Root

fn from_iter<I>(hashes: I) -> Self

where I: IntoIterator<Item = Hash>,

Panics

When there are no transactions in the iterator. This is impossible, because every block must have a coinbase transaction.

impl<T> FromIterator<T> for Root

where T: AsRef<Transaction>,

fn from_iter<I>(transactions: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl FromIterator<UnminedTx> for Root

fn from_iter<I>(transactions: I) -> Self

where I: IntoIterator<Item = UnminedTx>,

Creates a value from an iterator.

impl FromIterator<UnminedTxId> for Root

fn from_iter<I>(tx_ids: I) -> Self

where I: IntoIterator<Item = UnminedTxId>,

Creates a value from an iterator.

impl FromIterator<VerifiedUnminedTx> for Root

fn from_iter<I>(transactions: I) -> Self

where I: IntoIterator<Item = VerifiedUnminedTx>,

Creates a value from an iterator.

impl PartialEq for Root

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Root

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToHex for &Root

fn encode_hex<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

fn encode_hex_upper<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

impl ToHex for Root

fn encode_hex<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Lower case letters are used (e.g. f9b4ca)

fn encode_hex_upper<T: FromIterator<char>>(&self) -> T

Encode the hex strict representing self into the result. Upper case letters are used (e.g. F9B4CA)

impl Copy for Root

impl Eq for Root

impl StructuralPartialEq for Root