This section states the commitment that Zcash block headers carry, each rule cited to the ZIP or the protocol specification section that fixes it, and each object before its first use: the upgrade epochs over which it ranges, the node vector of its Merkle mountain range, the hashing of the tree and its root commitment, the authorising-data root and the block commitment hash of ZIP 244 that wraps the root from NU5, the header consensus rules, and the range of blocks to which each header commits.
ZIP 221 (Final), “FlyClient - Consensus-Layer Changes”, changes the semantics of the block header and the consensus rules from Heartwood. The 32 -byte header field that held the root of the Sapling note commitment tree instead commits to the root of a Merkle mountain range (Definition 3.1; ZIP 221, “Terminology”: a binary hash tree that admits appends of new leaves “without changing the value of existing nodes”) whose nodes carry aggregated metadata. Its leaves are the blocks from the last activation height below the committing block up to the parent of that block: the epoch tree of Definition 6.2. ZIP 221 thus deploys the invariant of Construction 5.1 restricted to one upgrade epoch, the heights from one activation height up to the next (Definition 6.1), and not from the genesis block. The tree and its node fields 1 to 14 are ZIP 221’s; fields 15 to 17 are ZIP 258’s (Draft, in force from NU6.3 by Definition 1.2); and from NU5 the root is committed as the first input of the block commitment hash, a personalised hash of the root together with the block’s authorising-data root (ZIP 244; “The block commitment hash”, §6.6). Seven node fields serve reasoning about difficulty without matching the node of Definition 5.6 (ePrint 2019/226, Definition 7) field for field (Remark 6.4). Each term of this paragraph carries here only its defining clause; its definition is in the subsection named.
The purpose of the commitment, after ZIP 221, “Motivation”, is to let a light client verify, with a number of headers logarithmic rather than linear in the chain length and correctly with high probability, the validity of a chain received from a full node, the inclusion of a block in it, and metadata of any block or range of blocks; the commitment also admits subtree proofs, which check only blocks later than the most recently verified one. Transaction inclusion within a block is left to ZIP 307 (Draft). No claim of this paragraph is proved in this section; the protocol that would realise it is that of “The FlyClient protocol” (§5), and its relation to the deployed commitment is classified in “The deployment boundary” (§7).
Let
For a block height
| n = η − α (η) ≥ 1 |
leaves
The epoch tree T η is an instance of Definition 3.19 under Bag L . Every node v of it, leaf, internal node, bagging node or root, carries one node vector of fields, serialised canonically by the map ser of Definition 6.5; that serialisation is used whenever a parent commitment is formed. The fields are numbered as in ZIP 221, “Tree Node specification”. For a block B η ′ with header hdr ′ , the leaf map sets both members of each earliest/latest pair from B η ′ itself:
field hashSubtreeCommitment is BlockHash (hdr ′) (Definition 2.3), in internal byte order and unpersonalised;
fields nEarliestTimestamp and nLatestTimestamp are the field nTime of hdr ′ ;
fields nEarliestTargetBits and nLatestTargetBits are the field nBits of hdr ′ (the semantics of nTime and nBits : Consensus Guide, §“Difficulty adjustment”);
fields hashEarliestSaplingRoot and hashLatestSaplingRoot are LEBS2OSP 256 (rt) for rt the root of the Sapling note commitment tree of the final Sapling treestate of B η ′ (protocol specification, §“Block Header Encoding and Consensus”), an opaque 32 -byte value in this volume;
field nSubTreeTotalWork is the work
| ⌊ 2 256 / (ToTarget (nBits) + 1) ⌋ |
of B η ′ (Consensus Guide, §“Work, and the best chain”, Definition “Work of a block”);
fields nEarliestHeight and nLatestHeight are the height η ′ ;
field nSaplingTxCount is the number of transactions of B η ′ in which vSpendsSapling or vOutputsSapling is non-empty;
fields hashEarliestOrchardRoot and hashLatestOrchardRoot are the Orchard-pool anchor of B η ′ , the root of the Orchard pool’s note commitment tree in the final treestate of B η ′ (Ironwood Guide, §“Anchors”, Definition “Treestate and anchor”);
field nOrchardTxCount is the number of transactions of B η ′ in which vActionsOrchard is non-empty (Ironwood Guide, §“The transaction format”);
fields hashEarliestIronwoodRoot , hashLatestIronwoodRoot and nIronwoodTxCount are the Ironwood-pool anchor of B η ′ and the number of its transactions in which vActionsIronwood is non-empty, computed as fields 12 to 14 .
The parent rule: an internal node with left child l and right child r takes each earliest field ( 2 , 4 , 6 , 9 , 12 , 15 ) from l and each latest field ( 3 , 5 , 7 , 10 , 13 , 16 ) from r ; it sums the additive fields, field 8 modulo 2 256 and the per-pool counts 11 , 14 and 17 in Z ; and it sets field 1 by Construction 6.10, the personalised hash of ser (l) ∥ ser (r) . Fields 12 to 14 are ZIP 221’s own, added at NU5 (ZIP 252). Fields 15 to 17 are ZIP 258’s, “Changes to ZIP 221” (Draft), whose rules apply from NU6.3 activation (Definition 1.2).
For field 8 , ZIP 221, “Tree Node specification”, states that computations modulo 2 256 are fine because cumulative chain work is assumed to be at most 2 256 , an aggregate effort of 2 256 or more being infeasible; under that assumption, with the total below 2 256 , the field of a node is the integer sum of the work of its leaves (Lemma 3.21(2)). Table 2 summarises the definition.
| Field | Type | Leaf value for B η ′ | Internal node | ZIP | |
|---|---|---|---|---|---|
| 1 | hashSubtreeCommitment | char[32] | BlockHash (hdr ′) | hash | 221 |
| 2 | nEarliestTimestamp | uint32 | nTime | inherit left | 221 |
| 3 | nLatestTimestamp | uint32 | nTime | inherit right | 221 |
| 4 | nEarliestTargetBits | uint32 | nBits | inherit left | 221 |
| 5 | nLatestTargetBits | uint32 | nBits | inherit right | 221 |
| 6 | hashEarliestSaplingRoot | char[32] | final Sapling root | inherit left | 221 |
| 7 | hashLatestSaplingRoot | char[32] | final Sapling root | inherit right | 221 |
| 8 | nSubTreeTotalWork | uint256 | work of the block | sum mod 2 256 | 221 |
| 9 | nEarliestHeight | CompactSize | height η ′ | inherit left | 221 |
| 10 | nLatestHeight | CompactSize | height η ′ | inherit right | 221 |
| 11 | nSaplingTxCount | CompactSize | transactions with Sapling spends or outputs | sum | 221 |
| 12 | hashEarliestOrchardRoot | char[32] | Orchard-pool anchor | inherit left | 221 |
| 13 | hashLatestOrchardRoot | char[32] | Orchard-pool anchor | inherit right | 221 |
| 14 | nOrchardTxCount | CompactSize | transactions with Orchard-pool Actions | sum | 221 |
| 15 | hashEarliestIronwoodRoot | char[32] | Ironwood-pool anchor | inherit left | 258 |
| 16 | hashLatestIronwoodRoot | char[32] | Ironwood-pool anchor | inherit right | 258 |
| 17 | nIronwoodTxCount | CompactSize | transactions with Ironwood-pool Actions | sum | 258 |
ZIP 221, “FlyClient Requirements and Recommendations”, designates seven
fields, 2 to 5 and 8 to 10 , which “enable FlyClient in the
variable-difficulty model” by letting a light client reason about the
application of the difficulty adjustment over a range of blocks. They serve
the purpose of Definition 5.6 without matching it field for
field. The leaf count of a node, the field n of the difficulty
MMR, is
Fields 6 , 7 and 11 to 14 are ZIP 221’s “Non-FlyClient Commitments”, chosen “primarily to improve light client security guarantees”, with no counterpart in ePrint 2019/226. Field 1 “forms the structure of the commitment tree” (ZIP 221, “Tree nodes”), and fields 15 to 17 are the ZIP 258 counterparts for the Ironwood pool. The earliest roots let a client check the treestate transitions over a range of blocks without recomputing the roots from genesis. ZIP 221, “Non-FlyClient Commitments”, states that hashLatestSaplingRoot serves the purpose of the former header field hashFinalSaplingRoot , one block delayed (Proposition 6.23). The per-pool counts follow the rule of the same section that a new shielded pool adds a count of its transactions, applied at NU5 (fields 12 to 14 ) and at NU6.3 (fields 15 to 17 , ZIP 258).
The fields are encoded as follows: a char[32] field as its 32 bytes; a uint32 or uint256 field little-endian, as I2LEOSP 32 or I2LEOSP 256 (protocol specification, §“Integers, Bit Sequences, and Endianness”); a height or count as its CompactSize encoding in minimal form (Definition 2.2); and each pool-root field as LEBS2OSP 256 of the root, as the specification encodes the Orchard anchor (protocol specification, §“Transaction Encoding and Consensus”). For a node v , ser (v) is the concatenation of the encodings of its fields in field order. The field vector of an upgrade epoch is:
fields 1 to 11 in the Heartwood and Canopy upgrade epochs;
fields 1 to 14 in the NU5, NU6, NU6.1 and NU6.2 upgrade epochs;
fields 1 to 17 in the NU6.3 and NU7 upgrade epochs.
The vectors are named by their fields. ZIP 221, “Tree Node specification”, omits fields 12 to 14 “before NU5 activation”, and ZIP 258, “Changes to ZIP 221”, omits fields 15 to 17 “before NU6.3 activation”; neither says whether the height of a leaf’s block or that of the committing block governs, and the two differ only for the tree committed by an activation block. Adopted reading, resolving that ambiguity: every node of T η uses the field vector of the upgrade epoch beginning at α (η) , the upgrade epoch of its leaves.
The reading is adopted for the following reason. Under the other reading the tree T A committed by B A , at an activation height A that adds fields, would serialise every node of the previous upgrade epoch with the added fields; every internal node would change value, and T A would not be an append of T A − 1 , contrary to the property by which ZIP 221, “Terminology”, defines a Merkle mountain range. The ZIP’s pseudocode, which takes a leaf’s Orchard fields from the leaf’s own block and serialises them only when present, is consistent with the reading. Two consequences rest on it: T A uses the previous upgrade epoch’s vector, and T A + 1 is the first tree with the new one; under the other reading T A would carry the new vector. For NU7, no ZIP among the sources of NU7 consensus changes listed in ZIP 259 (Draft), “NU7 consensus changes”, amends ZIP 221 or ZIP 244, so the nodes of the trees of the NU7 upgrade epoch carry fields 1 to 17 under either reading.
The fixed-width fields occupy 144 , 208 and 272 bytes in the three vectors, and the three, four and five CompactSize fields 1 to 9 bytes each, so a serialised node has 147 to 171 , 212 to 244 and 277 to 317 bytes, the ranges that ZIP 221 and ZIP 258 state. A toy chain computed by script illustrates the reading, with an activation block that commits a tree of the previous vector and the next block the first to commit a tree of the new one; it establishes nothing.
Every node v of T η , bagging nodes included, spans a run of
consecutive leaves
By induction on the parent rule of Definition 6.3. A leaf
has both heights equal to its block’s. An internal node inherits
nEarliestHeight from its left child and nLatestHeight
from its right child, and in a range under Bag L the run of the
left child immediately precedes that of the right child, the heights of the
leaves of T η being consecutive by
Definition 6.2. A perfect subtree of altitude a spans
2 a leaves (Definition 3.1), and every node inside a peak roots a
perfect subtree. A bagging node of the left fold spans the peaks
For
Consensus bounds the field nTime of a block below, strictly above
the median of the timestamps of the preceding eleven blocks, and above, by
that median plus 90 minutes (protocol specification, §“Block Header
Encoding and Consensus”; Consensus Guide, §“Difficulty adjustment”). It orders two timestamps only at a distance: the
median-time-past never decreases and rises by at least one second every
eleven blocks, so a block at least
The tree is defined from the prose of ZIP 221, “Background”, “Specification”, “Tree Node specification” and “Block header semantics and consensus rules”, with ZIP 258, “Changes to ZIP 221”. That prose is ambiguous at two points, both at an activation block: the field vector, settled by the adopted reading of Definition 6.5, and the branch ID of the personalisation, settled by Definition 6.9. The pseudocode of ZIP 221 is cited only as corroboration of the two readings; it carries editorial defects, among them in the serialisation of the Orchard fields, none of which bears on either reading.
ZIP 221, “Tree Node specification”, states that the personalisation
encodes “the consensus branch ID for the epoch of the block containing the
commitment”, and continues: “Which is to say, each node in the tree
commits to the consensus branch that produced it.” The two sentences agree
at every
The reading is adopted for three reasons. (1) “Which is to say” introduces the second sentence as a restatement of the first, and it is the sentence that assigns a branch ID to each node. (2) Under the first reading the tree committed by B A would not be an append of the tree committed by B A − 1 , every internal node changing value, contrary to the property by which ZIP 221, “Terminology”, defines a Merkle mountain range (the reason for which Definition 6.5 adopts the leaves’ vector); and the whole previous upgrade epoch would be rehashed in one block, the cost that ZIP 221, “Header Format Change”, calls impractical and avoids by a special case at the Heartwood activation block and at no later one. (3) The pseudocode of ZIP 221 hashes each parent under the branch ID of its left child and the root commitment under that of the root node, each leaf carrying the branch ID of its own block. Every later statement about the tree committed by an activation block rests on this reading and cites it; under the first reading each holds with the branch ID of the new upgrade epoch in place of b (T A) .
Let h (P, x) be BLAKE2b-256 with the 16 -byte personalisation P on input x (Ironwood Guide, §“Transaction digests and signatures”; Crypto Guide, §“Domain separation and personalisation”), and let β be the 4 -byte little-endian encoding of b (T η) . The personalisation is the 12 ASCII bytes ZcashHistory followed by β , 16 bytes in all. The tree T η is the range M n L whose nodes are node vectors (Definition 6.3) under the field vector of Definition 6.5. Its bagging nodes, which join the two leftmost remaining peaks until one remains,
| (⋯ ((P 1 ∥ P 2) ∥ P 3) ⋯) ∥ P d, |
are ordinary internal nodes, and a single peak is the root node. For an internal node with children l and r , field 1 is
| h (ZcashHistory ∥ β, ser (l) ∥ ser (r)), |
over the children’s full serialisations; its other fields follow the parent rule of Definition 6.3. The branch ID is not a node field: it enters only through the personalisation, and whoever recomputes a node hash supplies b (T η) by Definition 6.9, the upgrade epoch being fixed by the node’s heights. For the Heartwood branch ID 0xF5B9230B the last four bytes of the personalisation are 0B 23 B9F5 .
| Upgrade epoch | Branch ID | Fixed by | Bytes 13 to 16 of the personalisation | Fields |
|---|---|---|---|---|
| Heartwood | 0xF5B9230B | ZIP 250 | 0B 23 B9F5 | 1 to 11 |
| Canopy | 0xE9FF75A6 | ZIP 251 | A6 75 FFE9 | 1 to 11 |
| NU5 | 0xC2D6D0B4 | ZIP 252 | B4D0D6C2 | 1 to 14 |
| NU6 | 0xC8E71055 | ZIP 253 | 55 10 E7C8 | 1 to 14 |
| NU6.1 | 0x4DEC4DF0 | ZIP 255 | F0 4 DEC 4 D | 1 to 14 |
| NU6.2 | 0x5437F330 | ZIP 257 | 30F3 37 54 | 1 to 14 |
| NU6.3 | 0x37A5165B | ZIP 258 (Draft) | 5B 16 A5 37 | 1 to 17 |
| NU7 | 0x77190AD9 | ZIP 259 (Draft) | D9 0 A 19 77 | 1 to 17 |
For
| hashChainHistoryRoot (T η) := h (ZcashHistory ∥ β, ser (root node of T η)), |
with β encoding b (T η) (ZIP 221, “Tree Node
specification”). It is not field 1 of the root node: the committed value
covers the root’s aggregates, namely the total work modulo 2 256 , the
first and last timestamps, target bits and heights, the boundary pool roots
and the per-pool counts. When
For
| hashLightClientRoot (η) := { the string of 32 zero bytes if η = A H, hashChainHistoryRoot (T η) if η > A H . |
The value at A H is the sentinel that ZIP 221, “Block header semantics and consensus rules”, requires in the Heartwood activation block and states “MUST NOT be interpreted as a root hash”. The history input is a total function of the height from A H on, and it is the value that ZIP 244, “Block Header Changes”, names “hashLightClientRoot (as described in ZIP 221)”.
Let T and T ′ be epoch trees hashed under one branch
ID b . If
The proposition is the ZIP 221 instance of Lemma 3.20(1), whose hypotheses are checked as follows. Serialisation. The branch ID b fixes one upgrade epoch and hence one field vector for both trees (Table 3; Definitions 6.9 and 6.5). Its field order is fixed, and each field is of fixed width or a minimal CompactSize, whose first byte fixes its length (Definition 2.2). A serialised node therefore parses field by field: ser is injective, and no serialised node is a proper prefix of another, since the two parse to the same fields up to the end of the shorter and the number of fields is fixed; minimality makes ser a function of the node. Root and shape. If the root commitments are equal, then the two root serialisations are equal, or they are distinct inputs with equal images, a collision. Equal root nodes have equal nEarliestHeight and nLatestHeight , hence equal leaf count n by Lemma 6.6, hence the same shape M n L . The shape fixes which positions are leaves, so no leaf of one tree is compared with an internal node of the other, although the tree carries no layer tags (ZIP 221, “Tree nodes”, identifies leaves by their block range of 1 ). Extraction. Lemma 3.20(1) then yields a collision at the first level of disagreement. Headers. Field 1 of each leaf is the SHA-256d block hash of its header (Definition 2.3; Crypto Guide, §“The transparent layer’s hashes”); equal leaves with distinct headers are a collision of SHA-256d. □
Let a node v of T η be authenticated by an inclusion path (Definition 3.13, in the tuple form of Definition 3.19, siblings as full node vectors) accepted against the chain-history root of the epoch tree of a chain the client trusts. Barring a collision as in Proposition 6.13, v . nSaplingTxCount , and where present v . nOrchardTxCount and v . nIronwoodTxCount , equal the numbers of transactions in the blocks of the height range of v in which vSpendsSapling or vOutputsSapling , vActionsOrchard and vActionsIronwood , respectively, are non-empty. Hence a client that obtains the transactions of those blocks, each authenticated against its block’s transaction root, detects the withholding of any such transaction by a count mismatch, and a range whose count is zero contains none and may be skipped; the count does not identify the missing transaction.
By Lemma 3.20(2), an accepted path binds the full vector of every node it recomputes and of every sibling it carries, so v is the node of the trusted tree at its position, barring a collision; the serialisation is prefix-free by the proof of Proposition 6.13. In that tree the count fields are consistent, and by the parent rule of Definition 6.3 and Lemma 6.6 the value of each count field of v is its sum over the leaves of v ’s height range. The reading as detection of withholding is ZIP 221, “Non-FlyClient Commitments”. □
For branch IDs
| h (ZcashHistory ∥ β, x) = h (ZcashHistory ∥ β ′, x ′) |
with probability at most q 2 / 2 256 . Hence no internal-node hash or root commitment computed under b equals one computed under b ′ , except with that probability. Leaves are unpersonalised block hashes, identical in every branch, and are not separated.
The modelling hypothesis is that of the Crypto Guide, §“Domain separation and personalisation”, Proposition “Domain separation yields independent oracles”: distinct tags give independent random oracles. Both values must be answers to queries, one to each oracle; each of the at most q 2 pairs of such queries agrees with probability 2 − 256 , and the union bound (Math Guide, §“The union bound and a birthday calculation”) gives the bound. ZIP 221, “Tree nodes”, states the design intent: “valid nodes from one consensus branch cannot be used to make false statements about parallel consensus branches”. □
The header field hashMerkleRoot (Definition 2.3) is the root of Bitcoin’s SHA-256d transaction Merkle tree over the transaction identifiers of the block (protocol specification, §“Block Header Encoding and Consensus”). The identifier of a version- 5 or version- 6 transaction excludes its authorising data (ZIP 244; Ironwood Guide, §“Transaction digests and signatures”, Definition “Authorising-data digest; effecting and authorising data”), so for such transactions hashMerkleRoot does not commit to the authorising data; the identifier of a version- 4 transaction covers its whole encoding. The version- 4 format is valid until NU7, from which ZIP 2003 (Draft), deployed by ZIP 259 (Draft), makes it invalid.
Let a block have the transactions
Assume, with ZIP 244, “Authorizing Data Commitment”, that the pair of a
transaction’s identifier and its authorising-data commitment is binding:
distinct transactions with equal pairs form a collision of that pair map.
Let two lists of m transactions have equal hashMerkleRoot and
equal hashAuthDataRoot . Then the lists are equal, or a collision
of SHA-256d, of
For fixed m , Bitcoin’s duplication rule and the zero padding of
Construction 6.16 are fixed maps of the list, so the path
argument of the Crypto Guide, §“Binary Merkle trees”, Proposition
“Binding of the root”, applies to each tree: the two lists of identifiers
agree, else a collision of SHA-256d is extracted, and the two lists of
authorising-data commitments agree, else a collision of
In this subsection 0 32 denotes the string of 32 zero bytes.
For a block B η at a height in or after the NU5 upgrade epoch, the block commitment hash is
| hashBlockCommitments (B η) := h (ZcashBlockCommit, hashLightClientRoot (η) ‖ hashAuthDataRoot (B η) ‖ 0 32), |
with hashLightClientRoot (η) the history input of
Definition 6.12, hashAuthDataRoot (B η) the
root of Construction 6.16 for B η , and 0 32 the
terminator (ZIP 244, “Block Header Changes”). The input has
From NU5 the chain-history root appears in no header. Let c be the value
hashBlockCommitments (B η) of a block in or after the NU5
upgrade epoch. A verifier given a claimed history input r , or a claimed
root node vector from which it computes
| c = h (ZcashBlockCommit, r ‖ a ‖ 0 32) ; |
only the 32 -byte value of hashAuthDataRoot is needed, not its
tree. Two distinct accepted pairs
The pair (hashLightClientRoot (η), hashAuthDataRoot (B η)) is accepted by Definition 6.18. The input r ‖ a ‖ 0 32 has fixed length, so distinct pairs give distinct inputs, and two accepted pairs with equal image c are a collision. □
ZIP 244, “Block Header Changes”, treats the value as “a linked list of hashes terminated by arbitrary data”: a later upgrade may replace the terminator by the hash of a new structure that ends in its own terminator. The same section states two interoperability rules: fully validating nodes MUST always use the entire structure defined by the latest activated protocol version they support, and a third-party server that supports a later protocol version SHOULD provide a value that can be used in place of the all-zero terminator, so that a light client can validate the parts it needs. No upgrade through NU7 replaces the terminator: ZIP 258, “Changes to ZIP 221”, leaves hashBlockCommitments “unaffected” beyond the added node fields; ZIP 229, “Block Commitments”, changes no structure; and no source of NU7 consensus changes listed in ZIP 259, “NU7 consensus changes”, amends ZIP 244.
The 32 -byte header field that follows hashMerkleRoot (Definition 2.3) is named hashReserved before Sapling, hashFinalSaplingRoot in the Sapling and Blossom upgrade epochs, hashLightClientRoot in the Heartwood and Canopy upgrade epochs, and hashBlockCommitments from NU5 (protocol specification, §“Block Header Encoding and Consensus”; ZIP 221, “Block header semantics and consensus rules”; ZIP 244, “Block Header Changes”). The header byte format and version are unchanged by each renaming.
For a block B η the commitment field satisfies the following rules.
For
For
For η in or after the NU5 upgrade epoch, the NU5 activation block included and without sentinel, it MUST equal hashBlockCommitments (B η) of Definition 6.18.
(ZIP 221, “Block header semantics and consensus rules”; ZIP 244, “Block Header Changes”; protocol specification, §“Block Header Encoding and Consensus”.) The value is undefined for the genesis block, which no case covers.
In the NU5 activation block B A NU5 , A NU5 the NU5 activation height, the history input is hashChainHistoryRoot (T A NU5) , the root of the completed tree of the Canopy upgrade epoch. It is hashed under the Canopy branch ID 0xE9FF75A6 (ZIP 251) by the adopted reading of Definition 6.9, the first sentence of ZIP 221 giving the NU5 branch ID instead, and it is built from nodes of fields 1 to 11 by the adopted reading of Definition 6.5. By Definition 6.22 every valid block after the Heartwood activation block commits to the root of its epoch tree: directly in the Heartwood and Canopy upgrade epochs, and from NU5 as the first input of the block commitment hash.
For
By Definition 6.2, η lies outside
Let
B A commits to the complete tree T A over
B A + 1 commits to the single-leaf tree over B A ;
for
the reset occurs at every upgrade, including those that leave the field vector unchanged (Canopy, NU6, NU6.1, NU6.2 and NU7).
By the definition of α ,
Figure 4 shows the ranges of the theorem.
The height A H is an activation height below every
Let A NU7 be the NU7 activation height. The block B A NU7 commits, as the first input of its block commitment hash, to the completed tree of the NU6.3 upgrade epoch, hashed under the NU6.3 branch ID 0x37A5165B by the adopted reading of Definition 6.9. The block B A NU7 + 1 commits to a new tree over B A NU7 , hashed under the NU7 branch ID 0x77190AD9 (ZIP 259, Draft) with the field vector of Definition 6.5 for the NU7 upgrade epoch.