<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE rfc [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>
<?xml-stylesheet type="text/xsl" href="rfc2629.xslt" ?>
<!-- generated by https://github.com/cabo/kramdown-rfc version 1.7.43 (Ruby 3.4.12) -->
<rfc xmlns:xi="http://www.w3.org/2001/XInclude" ipr="trust200902" docName="draft-bryce-cose-receipts-mmr-profile-04" category="std" consensus="true" submissionType="IETF" tocInclude="true" sortRefs="true" symRefs="true" version="3">
  <!-- xml2rfc v2v3 conversion 3.35.0 -->
  <front>
    <title abbrev="COSE Receipts for MMRs">COSE Receipts for MMRs</title>
    <seriesInfo name="Internet-Draft" value="draft-bryce-cose-receipts-mmr-profile-04"/>
    <author fullname="Robin Bryce">
      <organization/>
      <address>
        <email>robinbryce@proton.me</email>
      </address>
    </author>
    <author fullname="Jon Geater">
      <organization/>
      <address>
        <email>jonathan@bowball-tech.com</email>
      </address>
    </author>
    <date year="2026" month="November" day="21"/>
    <area>Security</area>
    <workgroup>TBD</workgroup>
    <keyword>Internet-Draft</keyword>
    <abstract>
      <?line 71?>

<t>This document defines a new verifiable data structure type for COSE Receipts <xref target="RFC9942"/> specifically for use with ledgers based on post-order traversal binary Merkle trees and which are designed for high throughput, ease of replication and compatibility with commodity cloud storage.</t>
      <t>Post-order traversal binary Merkle trees, also known as history trees, are more commonly known as Merkle Mountain Ranges.</t>
    </abstract>
  </front>
  <middle>
    <?line 77?>

<section anchor="introduction">
      <name>Introduction</name>
      <t>The COSE Receipts document <xref target="RFC9942"/> defines a common framework for defining different types of proofs, such as proof of inclusion, about verifiable data structures (VDS). For instance, inclusion proofs guarantee to a verifier that a given serializable element is recorded at a given state of the VDS, while consistency proofs are used to establish that an inclusion proof is still consistent with the new state of the VDS at a later time.</t>
      <t>In this document, we define a new type of VDS: a post ordered binary merkle tree <xref target="KnuthTBT"/> is, logically, the unique series of perfect binary merkle trees required to commit its leaves. Such structures are also commonly known as Merkle Mountain Ranges <xref target="PeterTodd"/>.</t>
      <t>Example,</t>
      <artwork><![CDATA[
   6
 2   5
0 1 3 4 7
]]></artwork>
      <t>This illustrates <tt>MMR(8)</tt>, which is comprised of two perfect trees rooted at 6 and 7.
7 is the root of a tree comprised of a single element.</t>
      <t>The peaks of the perfect trees form the accumulator.</t>
      <t>The storage of a tree maintained in this way is addressed as a linear array, and additions to the tree are always appends.</t>
      <t>Proving and verifying are defined in terms of the cryptographic asynchronous accumulator described by <xref target="ReyzinYakoubov"/>.
The technical advantages of post-order traversal binary Merkle trees are discussed in <xref target="CrosbyWallach"/> (Section 3.3, "Storing the log on secondary storage") and <xref target="PostOrderTlog"/>.</t>
    </section>
    <section anchor="conventions-and-definitions">
      <name>Conventions and Definitions</name>
      <t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>", "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>", "<bcp14>SHALL
NOT</bcp14>", "<bcp14>SHOULD</bcp14>", "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>", "<bcp14>NOT RECOMMENDED</bcp14>",
"<bcp14>MAY</bcp14>", and "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as
described in BCP 14 <xref target="RFC2119"/> <xref target="RFC8174"/> when, and only when, they
appear in all capitals, as shown here.</t>
      <?line -18?>

<ul spacing="normal">
        <li>
          <t>A complete MMR(n) defines an mmr with n nodes where no equal height sibling trees exist. MMR(n) is complete if and only if <tt>index_height(n)</tt> is 0, that is, the node that would be stored at index n is a leaf.</t>
        </li>
        <li>
          <t><tt>i</tt> shall be the zero-based index of any node, including leaf nodes, in the MMR. Nodes are assigned indices in the order they are appended to the linear array.</t>
        </li>
        <li>
          <t><tt>pos</tt> shall be the one-based position of a node, <tt>pos = i + 1</tt>. The position is included in the hash of each interior node (see hash_pospair64), binding each interior node's value to its location in the tree.</t>
        </li>
        <li>
          <t>g shall be the zero-based height of a node in the tree.</t>
        </li>
        <li>
          <t><tt>H(x)</tt> shall be the SHA-256 digest of any value x</t>
        </li>
        <li>
          <t><tt>||</tt> shall mean concatenation of raw byte representations of the referenced values.</t>
        </li>
      </ul>
      <t>In this specification, all numbers are unsigned 64 bit integers.
The maximum height of a single tree is 63 (which will have <tt>g=62</tt> for its peak), so that every quantity the algorithms compute, in particular the sibling offset <tt>2^(g+1)</tt>, fits in 64 bits.
A tree of that height has <tt>2^63 - 1</tt> nodes.</t>
    </section>
    <section anchor="description-of-the-verifiable-data-structure">
      <name>Description of the Verifiable Data Structure</name>
      <t>This documents extends the verifiable data structure registry of <xref target="RFC9942"/> with the following value:</t>
      <table align="left" anchor="verifiable-data-structure-values">
        <name>Verifiable Data Structure Algorithms</name>
        <thead>
          <tr>
            <th align="left">Name</th>
            <th align="left">Value</th>
            <th align="left">Description</th>
            <th align="left">Reference</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td align="left">MMR_SHA256</td>
            <td align="left">TBD_1 (requested assignment 3)</td>
            <td align="left">Linearly addressed, position committing, MMR implementations, such as the MMR ledger</td>
            <td align="left">This document</td>
          </tr>
        </tbody>
      </table>
    </section>
    <section anchor="inclusion-proofs">
      <name>Inclusion Proofs</name>
      <t>The CBOR representation of an inclusion proof is</t>
      <sourcecode type="cddl"><![CDATA[
; a node value: the output of H, 32 bytes for SHA-256
hash = bstr .size 32

inclusion-proof = bstr .cbor inclusion-proof-content

inclusion-proof-content = [

  ; zero-based index of a tree node
  index: uint

  ; path proving the node's inclusion,
  ; empty when the node is a peak
  inclusion-path: [ * hash ]
]
]]></sourcecode>
      <t>Every element of an inclusion-path, a consistency-path or right-peaks is a node value.
A node value size is a constant specified by the hash algorithm.
A verifier <bcp14>MUST</bcp14> reject a proof in which any such element does not match the hash algorithm value size.</t>
      <t>Note that the inclusion path for the index leads to a single permanent node in the tree.
This node will initially be a peak in the accumulator, as the tree grows it will eventually be "buried" by a new peak.</t>
      <section anchor="inclusionproofpath">
        <name>inclusion_proof_path</name>
        <t><tt>inclusion_proof_path(i, c)</tt> is used to produce the verification paths for inclusion proofs and consistency proofs.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>c</tt> the index of the last node in any tree which contains <tt>i</tt>.</t>
          </li>
          <li>
            <t><tt>i</tt> the index of the mmr node whose verification path is required.</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="indexheight">index_height</xref> which obtains the zero-based height <tt>g</tt> of any node.</t>
          </li>
        </ul>
        <t>And the constraints:</t>
        <ul spacing="normal">
          <li>
            <t><tt>i &lt;= c</tt></t>
          </li>
        </ul>
        <t>We define <tt>inclusion_proof_path</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def inclusion_proof_path(i, c):

    path = []

    g = index_height(i)

    while True:

      # The sibling of i is at i +/- 2^(g+1)
      siblingoffset = (2 << g)

      # If the index after i is higher, it is the left parent,
      # and i is the right sibling
      if index_height(i+1) > g:

        # The witness to the right sibling is offset behind i
        isibling = i - siblingoffset + 1

        # The parent of a right sibling is stored immediately
        # after
        i += 1
      else:

        # The witness to a left sibling is offset ahead of i
        isibling = i + siblingoffset - 1

        # The parent of a left sibling is stored immediately after
        # its right sibling
        i += siblingoffset

      # When the computed sibling exceeds the range of MMR(C+1),
      # we have completed the path
      if isibling > c:
          return path

      path.append(isibling)

      # Set g to the height of the next item in the path.
      g += 1
]]></sourcecode>
      </section>
    </section>
    <section anchor="cose-receipt-of-inclusion">
      <name>COSE Receipt of Inclusion</name>
      <t>The cbor representation of an inclusion proof is:</t>
      <sourcecode type="cddl"><![CDATA[
protected-header-map = {
  &(alg: 1) => int
  &(vds: 395) => int ; TBD_1, see IANA Considerations
  * cose-label => cose-value
}
]]></sourcecode>
      <ul spacing="normal">
        <li>
          <t>alg (label: 1): <bcp14>REQUIRED</bcp14>. Signature algorithm identifier. Value type: int.</t>
        </li>
        <li>
          <t>vds (label: 395): <bcp14>REQUIRED</bcp14>. verifiable data structure algorithm identifier, the value registered by this document (TBD_1). Value type: int.</t>
        </li>
      </ul>
      <t>The protected header <bcp14>MUST</bcp14> meet the encoding requirements given in <xref target="cose-receipt-of-consistency">COSE Receipt of Consistency</xref>, and a verifier <bcp14>MUST</bcp14> apply the same acceptance rules to it.</t>
      <t>The unprotected header for an inclusion proof signature is:</t>
      <sourcecode type="cddl"><![CDATA[
inclusion-proofs = [ + inclusion-proof ]

verifiable-proofs = {
  &(inclusion-proof: -1) => inclusion-proofs
}

unprotected-header-map = {
  &(vdp: 396) => verifiable-proofs
  * cose-label => cose-value
}
]]></sourcecode>
      <t>The payload of an inclusion proof signature is the tree peak committing to the nodes inclusion, or the node itself where the proof path is empty.
The algorithm <xref target="includedroot">included_root</xref> obtains this value.</t>
      <t>The payload <bcp14>MUST</bcp14> be detached.
Detaching the payload forces verifiers to recompute the root from the inclusion proof,
this protects against implementation errors where the signature is verified but the payload merkle root does not match the inclusion proof.</t>
      <section anchor="verifying-the-receipt-of-inclusion">
        <name>Verifying the Receipt of inclusion</name>
        <t>A receipt of inclusion proves that a value is a node of the tree.
When the inclusion-path is not empty, the path also binds the index because each step hashes the position of the parent; when it is empty, see <xref target="tree-size-of-a-receipt-of-inclusion">Tree size of a receipt of inclusion</xref>.</t>
        <t>Whether a node is a leaf, and what its entry commits to, are properties of the leaf commitment scheme, which this profile leaves to the application; see <xref target="leaf-commitment-scheme">Leaf commitment scheme</xref>.</t>
        <t>Perform the following, in order.
Verification fails if any step fails.</t>
        <ol spacing="normal" type="1"><li>
            <t>Decode the protected header. It <bcp14>MUST</bcp14> be deterministically encoded as required in <xref target="cose-receipt-of-consistency">COSE Receipt of Consistency</xref>; vds <bcp14>MUST</bcp14> be TBD_1. Labels the verifier does not recognise are skipped.</t>
          </li>
          <li>
            <t>Apply <xref target="includedroot">included_root</xref> to the index, the value and the inclusion-path. The result is the peak the path implies.</t>
          </li>
          <li>
            <t>Set the COSE Sign1 payload to the bytes of that peak and verify the signature of the COSE Sign1.</t>
          </li>
        </ol>
        <t>It is recommended that implementations return a single boolean result for Receipt verification operations, to reduce the chance of accepting a valid signature over an invalid inclusion proof.</t>
        <t>A verifier that holds a trusted tree size and accumulator can additionally check that the proven node is the accumulator peak for the index at that size, which fixes the length of the inclusion path and binds the index when the path is empty.</t>
      </section>
      <section anchor="includedroot">
        <name>included_root</name>
        <t>The algorithm <tt>included_root</tt> calculates the accumulator peak for the provided proof and node value.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>i</tt> is the index the <tt>nodeHash</tt> is to be shown at</t>
          </li>
          <li>
            <t><tt>nodehash</tt> the value whose inclusion is to be shown</t>
          </li>
          <li>
            <t><tt>proof</tt> is the path of sibling values committing i.</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="indexheight">index_height</xref> which obtains the zero-based height <tt>g</tt> of any node.</t>
          </li>
          <li>
            <t><xref target="hashpospair64">hash_pospair64</xref> which applies <tt>H</tt> to the new node position and its children.</t>
          </li>
        </ul>
        <t>We define <tt>included_root</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def included_root(i, nodehash, proof):

    root = nodehash

    g = index_height(i)

    for sibling in proof:

      # If the index after i is higher, it is the left parent,
      # and i is the right sibling

      if index_height(i + 1) > g:

        # The parent of a right sibling is stored immediately after

        i = i + 1

        # Set `root` to `H(i+1 || sibling || root)`
        root = hash_pospair64(i + 1, sibling, root)
      else:

        # The parent of a left sibling is stored immediately after
        # its right sibling.

        i = i + (2 << g)

        # Set `root` to `H(i+1 || root || sibling)`
        root = hash_pospair64(i + 1, root, sibling)

      # Set g to the height of the next item in the path.
      g = g + 1

    # If the path length was zero, the original nodehash is returned
    return root
]]></sourcecode>
      </section>
    </section>
    <section anchor="consistency-proof">
      <name>Consistency Proof</name>
      <t>A consistency proof shows that the accumulator, defined in <xref target="ReyzinYakoubov"/>,
for tree-size-1 is a prefix of the accumulator for tree-size-2.</t>
      <t>The signature is over the complete accumulator for tree-size-2 obtained using the proof and the, supplied, possibly empty, list of <tt>right-peaks</tt> which complete the accumulator for tree-size-2.
The detached payload is the node values of that accumulator concatenated in descending height order.</t>
      <t>The receipt of consistency is defined so that a chain of cumulative consistency proofs can be verified together.</t>
      <t>The cbor representation of a consistency proof is:</t>
      <sourcecode type="cddl"><![CDATA[
consistency-path = [ * hash ]

consistency-proof = bstr .cbor consistency-proof-content

consistency-proof-content = [

  ; previous tree size
  tree-size-1: uint

  ; latest tree size
  tree-size-2: uint

  ; the inclusion path from each accumulator peak in
  ; tree-size-1 to its new peak in tree-size-2.
  ; empty when tree-size-1 is 0: the empty tree has no peaks
  consistency-paths: [ * consistency-path ]

  ; the additional peaks that
  ; complete the accumulator for tree-size-2,
  ; when appended to those produced by the consistency paths
  right-peaks: [ * hash ]
]
]]></sourcecode>
      <section anchor="consistencyproofpaths">
        <name>consistency_proof_paths</name>
        <t>Produces the verification paths for inclusion of the peaks of tree-size-1 under the peaks of tree-size-2.</t>
        <t>right-peaks are the node values of the peaks of tree-size-2 that no consistency path leads to, in descending height order.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>ifrom</tt> is the last index of tree-size-1</t>
          </li>
          <li>
            <t><tt>ito</tt> is the last index of tree-size-2</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="inclusionproofpath">inclusion_proof_path</xref></t>
          </li>
          <li>
            <t><xref target="peaks"/></t>
          </li>
        </ul>
        <t>And the constraints:</t>
        <ul spacing="normal">
          <li>
            <t><tt>ifrom &lt;= ito</tt></t>
          </li>
        </ul>
        <t>We define <tt>consistency_proof_paths</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def consistency_proof_paths(ifrom, ito):

    proof = []

    for i in peaks(ifrom):
      proof.append(inclusion_proof_path(i, ito))

    return proof
]]></sourcecode>
      </section>
    </section>
    <section anchor="cose-receipt-of-consistency">
      <name>COSE Receipt of Consistency</name>
      <t>The cbor representation of the protected header of a receipt of consistency is:</t>
      <sourcecode type="cddl"><![CDATA[
protected-header-map = {
  &(alg: 1) => int
  &(vds: 395) => int ; TBD_1, see IANA Considerations
  &(tree-size-2: -65933) => uint ; TBD_2, private use until assigned
  * cose-label => cose-value
}
]]></sourcecode>
      <ul spacing="normal">
        <li>
          <t>alg (label: 1): <bcp14>REQUIRED</bcp14>. Signature algorithm identifier. Value type: int.</t>
        </li>
        <li>
          <t>vds (label: 395): <bcp14>REQUIRED</bcp14>. verifiable data structure algorithm identifier, the value registered by this document (TBD_1). Value type: int.</t>
        </li>
        <li>
          <t>tree-size-2 (label: TBD_2): <bcp14>REQUIRED</bcp14>. The tree size to which consistency is proven; the accumulator of this tree size is the detached payload. <bcp14>MUST</bcp14> equal tree-size-2 of the last consistency-proof in the unprotected header. Value type: uint (CBOR major type 0).</t>
        </li>
      </ul>
      <t>tree-size-1 is not carried in the protected header: the verifier holds the tree size and accumulator it verifies consistency from, as described in <xref target="verifying-the-receipt-of-consistency">Verifying the Receipt of consistency</xref>.
A receipt of consistency under this profile that omits the protected tree-size-2 <bcp14>MUST</bcp14> be rejected.</t>
      <t>The protected header <bcp14>MUST</bcp14> be encoded as deterministic CBOR (<xref target="RFC8949"/>, Section 4.2.1): definite lengths only, arguments in shortest form, and keys sorted in the bytewise lexicographic order of their encodings.
The protected header map <bcp14>MUST</bcp14> occupy the whole of the protected header byte string.
A verifier <bcp14>MUST</bcp14> reject a receipt whose protected header is not so encoded, contains duplicate labels, or contains bytes beyond the protected header map.
A verifier <bcp14>MUST</bcp14> ignore protected header labels it does not recognise, whatever the type of their values, unless the label is listed in the crit header parameter (<xref target="RFC9052"/>, Section 3.1).
tree-size-2 need not be listed in crit; a receipt that omits it is rejected regardless.
These requirements give the protected header a single encoding, so that a verifier can meet the duplicate-label prohibition of <xref target="RFC9052"/>, Section 9, by checking that labels strictly increase, without a general CBOR decoder.</t>
      <t>The unprotected header for a consistency proof signature is:</t>
      <sourcecode type="cddl"><![CDATA[
consistency-proofs = [ + consistency-proof ]

verifiable-proofs = {
  &(consistency-proof: -2) => consistency-proofs
}

unprotected-header-map = {
  &(vdp: 396) => verifiable-proofs
  * cose-label => cose-value
}
]]></sourcecode>
      <t>The payload <bcp14>MUST</bcp14> be detached.
Detaching the payload forces verifiers to recompute the roots from the consistency proofs.
This protects against implementation errors where the signature is verified but the payload is not genuinely produced by the included proof.</t>
      <section anchor="verifying-the-receipt-of-consistency">
        <name>Verifying the Receipt of consistency</name>
        <t>Verification accommodates verifying the result of a cumulative series of consistency proofs.</t>
        <t>The verifier <bcp14>MUST</bcp14> hold, from a source it already trusts, the tree size and the accumulator of the state it is verifying consistency from; these are referred to below as the trusted tree size and the trusted accumulator.
The empty tree, with tree size 0 and an empty accumulator, is a valid trusted state; see <xref target="the-empty-tree-as-trusted-state">The empty tree as trusted state</xref> for what verification from it establishes.</t>
        <t>Trusted state advances only forwards.
Step 3 below rejects a receipt whose first consistency-proof starts from any size other than the trusted size, including a receipt that starts from the empty tree once a later state is held.
A verifier <bcp14>MAY</bcp14> nevertheless choose to accept such a receipt, for example after a ledger has re-issued receipts under new credentials following a key compromise (<xref target="RFC9943"/>, Section 9.4.2), but it <bcp14>MUST</bcp14> do so as a new verification from a trusted state at the size the receipt declares, discarding the state it previously held, and <bcp14>MUST NOT</bcp14> treat the receipt as a continuation of that state.</t>
        <t>Perform the following, in order.
Verification fails if any step fails.</t>
        <ol spacing="normal" type="1"><li>
            <t>Decode the protected header. It <bcp14>MUST</bcp14> be deterministically encoded as required in <xref target="cose-receipt-of-consistency">COSE Receipt of Consistency</xref>; vds <bcp14>MUST</bcp14> be TBD_1; tree-size-2 <bcp14>MUST</bcp14> be present and <bcp14>MUST</bcp14> be an unsigned integer. Labels the verifier does not recognise are skipped.</t>
          </li>
          <li>
            <t>The protected tree-size-2 <bcp14>MUST</bcp14> equal tree-size-2 of the last consistency-proof.</t>
          </li>
          <li>
            <t>tree-size-1 of the first consistency-proof <bcp14>MUST</bcp14> equal the trusted tree size.</t>
          </li>
          <li>
            <t>Initialize sizefrom to the trusted tree size and accumulatorfrom to the trusted accumulator.</t>
          </li>
          <li>
            <t>For each consistency-proof, in order:
            </t>
            <ol spacing="normal" type="1"><li>
                <t>tree-size-1 of the proof <bcp14>MUST</bcp14> equal sizefrom.</t>
              </li>
              <li>
                <t>Apply <xref target="consistentroots">consistent_roots</xref> to sizefrom, tree-size-2 of the proof, accumulatorfrom and the consistency-paths of the proof, obtaining roots and nright.</t>
              </li>
              <li>
                <t>The length of right-peaks <bcp14>MUST</bcp14> equal nright.</t>
              </li>
              <li>
                <t>Set accumulatorfrom to roots followed by right-peaks, and sizefrom to tree-size-2 of the proof.</t>
              </li>
            </ol>
          </li>
          <li>
            <t>Use the final accumulatorfrom as the detached payload and verify the signature of the COSE Sign1.</t>
          </li>
        </ol>
        <t><tt>consistent_roots</tt> requires the proof to have exactly the shape the two sizes imply: tree-size-2 <bcp14>MUST</bcp14> be a complete MMR size; each consistency path <bcp14>MUST</bcp14> have exactly the length that <xref target="inclusionproofpath">inclusion_proof_path</xref> produces for its peak; and every path leading to the same peak of tree-size-2 <bcp14>MUST</bcp14> produce the same value.
The number of roots it returns and the number of right-peaks it requires are fixed by the two sizes.</t>
        <t>It is recommended that implementations return a single boolean result for Receipt verification operations, to reduce the chance of accepting a valid signature over an invalid consistency proof.</t>
        <section anchor="consistentroots">
          <name>consistent_roots</name>
          <t><tt>consistent_roots</tt> returns the peaks of the accumulator for tree-size-2 that the proof proves from the accumulator for tree-size-1, in descending height order, together with the number of right-peaks the prover must supply to complete that accumulator.
It requires the proof to have exactly the shape the two tree sizes imply.</t>
          <t>For a complete MMR the set bits of <xref target="leafcount">leaf_count</xref><tt>(size - 1)</tt> are the heights of the accumulator peaks, from the highest bit to the lowest, which is accumulator order.
Let <tt>split</tt> be the highest bit on which the leaf counts of the two sizes differ.
Because tree-size-2 is greater than tree-size-1, the target has that bit set and the origin does not.
An origin peak above <tt>split</tt> is also a peak of the target: its path is empty and its value is returned unchanged.
Every origin peak below <tt>split</tt> is committed by the target peak of height <tt>split</tt>: its path has length <tt>split - h</tt>, and every such path <bcp14>MUST</bcp14> produce the same value.
The remaining peaks of the target are below every origin peak, so no path reaches them; the prover supplies them as right-peaks and their number is returned.</t>
          <t>Given:</t>
          <ul spacing="normal">
            <li>
              <t><tt>sizefrom</tt> the trusted tree size, tree-size-1.</t>
            </li>
            <li>
              <t><tt>sizeto</tt> the tree size consistency is proven to, tree-size-2.</t>
            </li>
            <li>
              <t><tt>accumulatorfrom</tt> the node values of the accumulator for <tt>sizefrom</tt>.</t>
            </li>
            <li>
              <t><tt>proofs</tt> the consistency-paths, one for each entry in <tt>accumulatorfrom</tt>.</t>
            </li>
          </ul>
          <t>And the methods:</t>
          <ul spacing="normal">
            <li>
              <t><xref target="includedroot">included_root</xref></t>
            </li>
            <li>
              <t><xref target="leafcount">leaf_count</xref></t>
            </li>
            <li>
              <t><xref target="mmrsizeforleafcount">mmr_size_for_leaf_count</xref></t>
            </li>
            <li>
              <t><xref target="bitlength">bit_length</xref></t>
            </li>
            <li>
              <t><xref target="onescount">ones_count</xref></t>
            </li>
          </ul>
          <t>And the constraints:</t>
          <ul spacing="normal">
            <li>
              <t><tt>sizefrom &lt; sizeto</tt></t>
            </li>
            <li>
              <t><tt>sizeto</tt> is a complete MMR size.</t>
            </li>
            <li>
              <t><tt>sizefrom</tt> is a complete MMR size, or 0. This is not checked: every trusted size was itself a checked tree-size-2.</t>
            </li>
          </ul>
          <t>We define <tt>consistent_roots</tt> as</t>
          <sourcecode type="python"><![CDATA[
  def consistent_roots(
      sizefrom, sizeto, accumulatorfrom, proofs):

    # if sizeto <= sizefrom -> ERROR

    leavesto = leaf_count(sizeto - 1)
    # if mmr_size_for_leaf_count(leavesto) != sizeto -> ERROR

    if sizefrom > 0:
      leavesfrom = leaf_count(sizefrom - 1)
    else:
      leavesfrom = 0

    n = ones_count(leavesfrom)
    # if length(accumulatorfrom) != n -> ERROR
    # if length(proofs) != n -> ERROR

    nto = ones_count(leavesto)
    if n == 0:
      return [], nto

    # The highest bit on which the leaf counts differ.
    split = bit_length(leavesfrom ^ leavesto) - 1

    roots = []

    # The number of nodes preceding the sub tree of the
    # current origin peak. A peak of height h is at
    # offset + 2^(h+1) - 2, and its sub tree has 2^(h+1) - 1 nodes.
    offset = 0
    i = 0

    # Origin peaks above the split are peaks of the target.
    # The path is not read; requiring it to be empty
    # rejects unused material.
    for h in range(bit_length(leavesfrom) - 1, split, -1):
      if not (leavesfrom >> h) & 1:
        continue
      # if length(proofs[i]) != 0 -> ERROR
      roots.append(accumulatorfrom[i])
      offset += (1 << (h + 1)) - 1
      i += 1

    # Origin peaks below the split are all committed by the
    # target peak of height split, so each path has length
    # split - h and every path must produce the same value.
    above = len(roots)
    root = None
    for h in range(split - 1, -1, -1):
      if not (leavesfrom >> h) & 1:
        continue
      # if length(proofs[i]) != split - h -> ERROR
      subtree = (1 << (h + 1)) - 1
      proven = included_root(
          offset + subtree - 1, accumulatorfrom[i], proofs[i])
      if i == above:
        root = proven
      # elif proven != root -> ERROR
      offset += subtree
      i += 1

    if n > above:
      roots.append(root)

    return roots, nto - len(roots)
]]></sourcecode>
        </section>
      </section>
    </section>
    <section anchor="appending-a-leaf">
      <name>Appending a leaf</name>
      <t>An algorithm for appending to a tree maintained in post order layout is provided.</t>
      <section anchor="addleafhash">
        <name>add_leaf_hash</name>
        <t>When a new node is appended, if its height matches the height of its immediate predecessor, then the two equal height siblings <bcp14>MUST</bcp14> be merged.
Merging is defined as the append of a new node which takes the adjacent peaks as its left and right children.
This process <bcp14>MUST</bcp14> proceed until there are no more completable sub trees.</t>
        <t><tt>add_leaf_hash(f)</tt> adds the leaf hash value f to the tree.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>f</tt> the leaf value resulting from <tt>H(x)</tt> for the caller defined leaf value <tt>x</tt></t>
          </li>
          <li>
            <t><tt>db</tt> an interface supporting <tt>append(entry) -&gt; count</tt> and <tt>get(index) -&gt; entry</tt> methods.
<tt>append</tt> stores the entry and returns the number of nodes in the store after the append, which is the index at which the next node will be stored.</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="indexheight">index_height</xref></t>
          </li>
          <li>
            <t><xref target="hashpospair64"/></t>
          </li>
        </ul>
        <t>We define <tt>add_leaf_hash</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def add_leaf_hash(db, f: bytes):

    # Set g to 0, the height of the leaf item f
    g = 0

    # Set i to the index the next node will occupy, which is the
    # number of nodes after appending f
    i = db.append(f)

    # While the node that would be stored at i is a parent, which
    # is exactly when MMR(i) is not complete (#looptarget)
    while index_height(i) > g:

      # Set ileft to the index of the left child of i,
      # which is i - 2^(g+1)

      ileft = i - (2 << g)

      # Set iright to the index of the right child of i,
      # which is i - 1

      iright = i - 1

      # Set v to H(i + 1 || Get(ileft) || Get(iright))
      # Set i to the result of invoking Append(v)

      i = db.append(
        hash_pospair64(i+1, db.get(ileft), db.get(iright)))

      # Set g to the height of the node just appended, which is g + 1
      g += 1

    # i is the number of nodes, the MMR size after the append
    return i
]]></sourcecode>
        <t><tt>add_leaf_hash</tt> returns the MMR size after the append, which is a complete MMR size.
The index of the leaf itself is one less than the value of <tt>i</tt> immediately after the first append.</t>
      </section>
      <section anchor="node-values">
        <name>Node values</name>
        <t>Interior nodes in the tree <bcp14>MUST</bcp14> prefix the value provided to <tt>H(x)</tt> with <tt>pos</tt>.</t>
        <t>The value <tt>v</tt> for any interior node <bcp14>MUST</bcp14> be <tt>H(pos || Get(LEFT_CHILD) || Get(RIGHT_CHILD))</tt></t>
        <t>The algorithm for leaf addition is provided the result of <tt>H(x)</tt> directly.</t>
        <section anchor="hashpospair64">
          <name>hash_pospair64</name>
          <t>Returns <tt>H(pos || a || b)</tt></t>
          <t>Given:</t>
          <ul spacing="normal">
            <li>
              <t><tt>pos</tt> the one-based position of the node being computed</t>
            </li>
            <li>
              <t><tt>a</tt> the first value to include in the hash after <tt>pos</tt></t>
            </li>
            <li>
              <t><tt>b</tt> the second value to include in the hash after <tt>pos</tt></t>
            </li>
          </ul>
          <t>And the constraints:</t>
          <ul spacing="normal">
            <li>
              <t><tt>pos &lt; 2^64</tt></t>
            </li>
            <li>
              <t><tt>a</tt> and <tt>b</tt> <bcp14>MUST</bcp14> be hashes produced by the appropriate hash algorithm.</t>
            </li>
          </ul>
          <t>We define <tt>hash_pospair64</tt> as</t>
          <sourcecode type="python"><![CDATA[
  def hash_pospair64(pos, a, b):

    # Note: Hash algorithm agility is tbd, this example uses SHA-256
    h = hashlib.sha256()

    # Take the big endian representation of pos
    h.update(pos.to_bytes(8, byteorder="big", signed=False))
    h.update(a)
    h.update(b)
    return h.digest()
]]></sourcecode>
        </section>
      </section>
    </section>
    <section anchor="essential-supporting-algorithms">
      <name>Essential supporting algorithms</name>
      <section anchor="indexheight">
        <name>index_height</name>
        <t><tt>index_height(i)</tt> returns the zero-based height <tt>g</tt> of the node index <tt>i</tt></t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>i</tt> the index of any mmr node.</t>
          </li>
        </ul>
        <t>We define <tt>index_height</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def index_height(i) -> int:
    pos = i + 1
    while not all_ones(pos):
      pos = pos - most_sig_bit(pos) + 1

    return bit_length(pos) - 1
]]></sourcecode>
      </section>
      <section anchor="peaks">
        <name>peaks</name>
        <t><tt>peaks(i)</tt> returns the peak indices for <tt>MMR(i+1)</tt>, which is also its accumulator.</t>
        <t>Requires MMR(i+1) to be complete.
MMR(i+1) is complete if and only if <tt>index_height(i+1)</tt> is 0, that is, the next node to be appended would be a leaf; see <xref target="conventions-and-definitions">Conventions and Definitions</xref>.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>i</tt> the index of any mmr node.</t>
          </li>
        </ul>
        <t>We define <tt>peaks</tt></t>
        <sourcecode type="python"><![CDATA[
  def peaks(i):
    peak = 0
    peaks = []
    s = i+1
    while s != 0:
      # find the highest peak size in the current MMR(s)
      highest_size = (1 << log2floor(s+1)) - 1
      peak = peak + highest_size
      peaks.append(peak-1)
      s -= highest_size

    return peaks
]]></sourcecode>
      </section>
      <section anchor="leafcount">
        <name>leaf_count</name>
        <t><tt>leaf_count(i)</tt> returns the number of leaves in <tt>MMR(i+1)</tt>.</t>
        <t>The bits of the count also form a mask with a single bit set for each peak in the accumulator, where the bit position is the height of the peak.
Read from the highest bit to the lowest, the set bits give the accumulator peaks in order.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>i</tt> the index of any mmr node.</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="bitlength">bit_length</xref></t>
          </li>
        </ul>
        <t>We define <tt>leaf_count</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def leaf_count(i):
    s = i + 1

    peaksize = (1 << bit_length(s)) - 1
    peakmap = 0
    while peaksize > 0:
      peakmap <<= 1
      if s >= peaksize:
        s -= peaksize
        peakmap |= 1
      peaksize >>= 1

    return peakmap
]]></sourcecode>
      </section>
      <section anchor="mmrsizeforleafcount">
        <name>mmr_size_for_leaf_count</name>
        <t><tt>mmr_size_for_leaf_count(leaves)</tt> returns the number of nodes in the complete MMR with <tt>leaves</tt> leaves.</t>
        <t>Every leaf adds itself and one interior node for each binary carry, and each peak is a carry that has not happened.
Because <tt>leaf_count</tt> rounds an incomplete size down to the largest complete MMR below it, <tt>mmr_size_for_leaf_count(leaf_count(size - 1)) == size</tt> holds exactly when <tt>size</tt> is a complete MMR size.</t>
        <t>Given:</t>
        <ul spacing="normal">
          <li>
            <t><tt>leaves</tt> a leaf count.</t>
          </li>
        </ul>
        <t>And the methods:</t>
        <ul spacing="normal">
          <li>
            <t><xref target="onescount">ones_count</xref></t>
          </li>
        </ul>
        <t>We define <tt>mmr_size_for_leaf_count</tt> as</t>
        <sourcecode type="python"><![CDATA[
  def mmr_size_for_leaf_count(leaves):
    return 2 * leaves - ones_count(leaves)
]]></sourcecode>
      </section>
    </section>
    <section anchor="privacy-considerations">
      <name>Privacy Considerations</name>
      <t>See the privacy considerations section of <xref target="RFC9942"/>.</t>
      <t>This profile does not define the leaf pre-image <tt>x</tt>.
Confidentiality of entry contents, including resistance to guess-and-confirm of low-entropy entries, is the responsibility of the application that constructs <tt>x</tt> (for SCITT, see the privacy considerations of <xref target="RFC9943"/>).</t>
    </section>
    <section anchor="security-considerations">
      <name>Security Considerations</name>
      <t>The security considerations of <xref target="RFC9942"/> apply.</t>
      <section anchor="tree-size-of-a-receipt-of-inclusion">
        <name>Tree size of a receipt of inclusion</name>
        <t>A receipt of inclusion carries no tree size: it verifies in every later tree size, and alone does not tie the proven node to the history a verifier has established by receipts of consistency.
When the inclusion path is empty the signature is over the node value alone and the index is not bound.
An application that needs the position bound in this case can include it in the entry (see <xref target="leaf-commitment-scheme">Leaf commitment scheme</xref>) or check the node against a trusted accumulator for a tree size in which it is a peak.</t>
      </section>
      <section anchor="leaf-commitment-scheme">
        <name>Leaf commitment scheme</name>
        <t>Leaf values are not domain separated from interior values as they are in <xref target="RFC9162"/>: an <tt>x</tt> equal to the pre-image <tt>pos || left || right</tt> of an interior node hashes to that node.
With a non-empty inclusion path the position is bound and the height of the index shows whether the node is a leaf.
With an empty path such an <tt>x</tt> verifies as an entry at any leaf index.
An application should choose a form for <tt>x</tt> that no interior pre-image can take, for example a leading domain byte, and include the position in <tt>x</tt> if it needs the position bound when the path is empty.</t>
      </section>
      <section anchor="declared-tree-sizes">
        <name>Declared tree sizes</name>
        <t>The shape of a consistency proof does not fix tree-size-2 when there are right-peaks: a right-peak carries no height, so the same consistency paths and right-peaks complete the accumulator of every tree size that adds the same number of peaks.
A verifier that takes tree-size-2 from the unprotected proof, or omits the comparison with the protected tree-size-2, lets the presenter choose the size it records, and the ledger's next receipt then fails against that state although the ledger has behaved correctly.</t>
      </section>
      <section anchor="the-empty-tree-as-trusted-state">
        <name>The empty tree as trusted state</name>
        <t>Every accumulator is consistent with the empty tree.
A verifier that verifies from the empty tree places all of its trust in the signing key and the signed tree-size-2; the size it records is the signer's assertion, not a value derived from a state it held.
The rules for accepting such a receipt once a later state is held are given in <xref target="verifying-the-receipt-of-consistency">Verifying the Receipt of consistency</xref>.</t>
      </section>
    </section>
    <section anchor="iana-considerations">
      <name>IANA Considerations</name>
      <section anchor="additions-to-existing-registries">
        <name>Additions to Existing Registries</name>
        <section anchor="cose-verifiable-data-structure-algorithms">
          <name>COSE Verifiable Data Structure Algorithms</name>
          <t>IANA is requested to add the following value to the "COSE Verifiable Data Structure Algorithms" registry established by <xref target="RFC9942"/>:</t>
          <ul spacing="normal">
            <li>
              <t>Name: MMR_SHA256</t>
            </li>
            <li>
              <t>Value: TBD_1 (requested assignment 3)</t>
            </li>
            <li>
              <t>Description: Linearly addressed, position-committing, append-only logs that are integrity-protected by a post-order traversal (Merkle Mountain Range) binary Merkle tree using SHA-256.</t>
            </li>
            <li>
              <t>Reference: RFCthis</t>
            </li>
          </ul>
          <t>Editors note: Hash agility. This document defines a single SHA-256-based identifier, MMR_SHA256, following the convention of binding the hash function into the algorithm identifier. Additional identifiers (for example using BLAKE2b-256, SHA3-256, or SHA3-512, both of which are used by existing implementations) are expected to be registered as separate values in a future revision, rather than negotiated within a single identifier.</t>
        </section>
        <section anchor="cose-header-parameters">
          <name>COSE Header Parameters</name>
          <t>IANA is requested to add the following entry to the "COSE Header Parameters" registry established by <xref target="RFC9053"/>, in the Specification Required range:</t>
          <ul spacing="normal">
            <li>
              <t>Name: tree-size-2</t>
            </li>
            <li>
              <t>Label: TBD_2</t>
            </li>
            <li>
              <t>Value Type: uint</t>
            </li>
            <li>
              <t>Value Registry: none</t>
            </li>
            <li>
              <t>Description: The tree size to which a receipt of consistency proves consistency, and whose accumulator is its payload</t>
            </li>
            <li>
              <t>Reference: RFCthis</t>
            </li>
          </ul>
          <t>Until this label is assigned, implementations use the private use value -65933 for tree-size-2.</t>
        </section>
      </section>
      <section anchor="new-registries">
        <name>New Registries</name>
        <t>This document requests no new registries.</t>
      </section>
    </section>
  </middle>
  <back>
    <references anchor="sec-combined-references">
      <name>References</name>
      <references anchor="sec-normative-references">
        <name>Normative References</name>
        <reference anchor="RFC2119">
          <front>
            <title>Key words for use in RFCs to Indicate Requirement Levels</title>
            <author fullname="S. Bradner" initials="S." surname="Bradner"/>
            <date month="March" year="1997"/>
            <abstract>
              <t>In many standards track documents several words are used to signify the requirements in the specification. These words are often capitalized. This document defines these words as they should be interpreted in IETF documents. This document specifies an Internet Best Current Practices for the Internet Community, and requests discussion and suggestions for improvements.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="2119"/>
          <seriesInfo name="DOI" value="10.17487/RFC2119"/>
        </reference>
        <reference anchor="RFC8174">
          <front>
            <title>Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words</title>
            <author fullname="B. Leiba" initials="B." surname="Leiba"/>
            <date month="May" year="2017"/>
            <abstract>
              <t>RFC 2119 specifies common key words that may be used in protocol specifications. This document aims to reduce the ambiguity by clarifying that only UPPERCASE usage of the key words have the defined special meanings.</t>
            </abstract>
          </front>
          <seriesInfo name="BCP" value="14"/>
          <seriesInfo name="RFC" value="8174"/>
          <seriesInfo name="DOI" value="10.17487/RFC8174"/>
        </reference>
        <reference anchor="RFC8949">
          <front>
            <title>Concise Binary Object Representation (CBOR)</title>
            <author fullname="C. Bormann" initials="C." surname="Bormann"/>
            <author fullname="P. Hoffman" initials="P." surname="Hoffman"/>
            <date month="December" year="2020"/>
            <abstract>
              <t>The Concise Binary Object Representation (CBOR) is a data format whose design goals include the possibility of extremely small code size, fairly small message size, and extensibility without the need for version negotiation. These design goals make it different from earlier binary serializations such as ASN.1 and MessagePack.</t>
              <t>This document obsoletes RFC 7049, providing editorial improvements, new details, and errata fixes while keeping full compatibility with the interchange format of RFC 7049. It does not create a new version of the format.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="94"/>
          <seriesInfo name="RFC" value="8949"/>
          <seriesInfo name="DOI" value="10.17487/RFC8949"/>
        </reference>
        <reference anchor="RFC9052">
          <front>
            <title>CBOR Object Signing and Encryption (COSE): Structures and Process</title>
            <author fullname="J. Schaad" initials="J." surname="Schaad"/>
            <date month="August" year="2022"/>
            <abstract>
              <t>Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines the CBOR Object Signing and Encryption (COSE) protocol. This specification describes how to create and process signatures, message authentication codes, and encryption using CBOR for serialization. This specification additionally describes how to represent cryptographic keys using CBOR.</t>
              <t>This document, along with RFC 9053, obsoletes RFC 8152.</t>
            </abstract>
          </front>
          <seriesInfo name="STD" value="96"/>
          <seriesInfo name="RFC" value="9052"/>
          <seriesInfo name="DOI" value="10.17487/RFC9052"/>
        </reference>
        <reference anchor="RFC9053">
          <front>
            <title>CBOR Object Signing and Encryption (COSE): Initial Algorithms</title>
            <author fullname="J. Schaad" initials="J." surname="Schaad"/>
            <date month="August" year="2022"/>
            <abstract>
              <t>Concise Binary Object Representation (CBOR) is a data format designed for small code size and small message size. There is a need to be able to define basic security services for this data format. This document defines a set of algorithms that can be used with the CBOR Object Signing and Encryption (COSE) protocol (RFC 9052).</t>
              <t>This document, along with RFC 9052, obsoletes RFC 8152.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9053"/>
          <seriesInfo name="DOI" value="10.17487/RFC9053"/>
        </reference>
        <reference anchor="RFC9942">
          <front>
            <title>CBOR Object Signing and Encryption (COSE) Receipts</title>
            <author fullname="O. Steele" initials="O." surname="Steele"/>
            <author fullname="H. Birkholz" initials="H." surname="Birkholz"/>
            <author fullname="A. Delignat-Lavaud" initials="A." surname="Delignat-Lavaud"/>
            <author fullname="C. Fournet" initials="C." surname="Fournet"/>
            <date month="June" year="2026"/>
            <abstract>
              <t>CBOR Object Signing and Encryption (COSE) Receipts prove properties of a Verifiable Data Structure (VDS) to a verifier. VDSs and associated Proof Types enable security properties, such as minimal disclosure, transparency, and non-equivocation. Transparency helps maintain trust over time and has been applied to certificates, end-to-end encrypted messaging systems, and supply chain security. This specification enables concise transparency-oriented systems by building on Concise Binary Object Representation (CBOR) and COSE. The extensibility of the approach is demonstrated by providing CBOR encodings for Merkle inclusion and consistency proofs.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9942"/>
          <seriesInfo name="DOI" value="10.17487/RFC9942"/>
        </reference>
      </references>
      <references anchor="sec-informative-references">
        <name>Informative References</name>
        <reference anchor="RFC9162">
          <front>
            <title>Certificate Transparency Version 2.0</title>
            <author fullname="B. Laurie" initials="B." surname="Laurie"/>
            <author fullname="E. Messeri" initials="E." surname="Messeri"/>
            <author fullname="R. Stradling" initials="R." surname="Stradling"/>
            <date month="December" year="2021"/>
            <abstract>
              <t>This document describes version 2.0 of the Certificate Transparency (CT) protocol for publicly logging the existence of Transport Layer Security (TLS) server certificates as they are issued or observed, in a manner that allows anyone to audit certification authority (CA) activity and notice the issuance of suspect certificates as well as to audit the certificate logs themselves. The intent is that eventually clients would refuse to honor certificates that do not appear in a log, effectively forcing CAs to add all issued certificates to the logs.</t>
              <t>This document obsoletes RFC 6962. It also specifies a new TLS extension that is used to send various CT log artifacts.</t>
              <t>Logs are network services that implement the protocol operations for submissions and queries that are defined in this document.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9162"/>
          <seriesInfo name="DOI" value="10.17487/RFC9162"/>
        </reference>
        <reference anchor="RFC9943">
          <front>
            <title>An Architecture for Trustworthy and Transparent Digital Supply Chains</title>
            <author fullname="H. Birkholz" initials="H." surname="Birkholz"/>
            <author fullname="A. Delignat-Lavaud" initials="A." surname="Delignat-Lavaud"/>
            <author fullname="C. Fournet" initials="C." surname="Fournet"/>
            <author fullname="Y. Deshpande" initials="Y." surname="Deshpande"/>
            <author fullname="S. Lasker" initials="S." surname="Lasker"/>
            <date month="June" year="2026"/>
            <abstract>
              <t>Traceability in supply chains is a growing security concern. While Verifiable Data Structures (VDSs) have addressed specific issues, such as equivocation over digital certificates, they lack a universal architecture for all supply chains. This document defines such an architecture for single-issuer signed statement transparency. It ensures extensibility and interoperability between different transparency services as well as compliance with various auditing procedures and regulatory requirements.</t>
            </abstract>
          </front>
          <seriesInfo name="RFC" value="9943"/>
          <seriesInfo name="DOI" value="10.17487/RFC9943"/>
        </reference>
        <reference anchor="ReyzinYakoubov" target="https://eprint.iacr.org/2015/718.pdf">
          <front>
            <title>Efficient Asynchronous Accumulators for Distributed PKI</title>
            <author initials="L." surname="Reyzin" fullname="Leonid Reyzin">
              <organization/>
            </author>
            <author initials="S." surname="Yakoubov" fullname="Sophia Yakoubov">
              <organization/>
            </author>
            <date year="2015"/>
          </front>
        </reference>
        <reference anchor="CrosbyWallach" target="https://static.usenix.org/event/sec09/tech/full_papers/crosby.pdf">
          <front>
            <title>Efficient Data Structures for Tamper-Evident Logging</title>
            <author initials="S. A." surname="Crosby" fullname="Scott A. Crosby">
              <organization/>
            </author>
            <author initials="D. S." surname="Wallach" fullname="Dan S. Wallach">
              <organization/>
            </author>
            <date year="2009"/>
          </front>
        </reference>
        <reference anchor="PostOrderTlog" target="https://research.swtch.com/tlog#appendix_a">
          <front>
            <title>Transparent Logs for Skeptical Clients (Appendix A: Storing the Log)</title>
            <author initials="R." surname="Cox" fullname="Russ Cox">
              <organization/>
            </author>
            <date year="2019"/>
          </front>
        </reference>
        <reference anchor="PeterTodd" target="https://lists.linuxfoundation.org/pipermail/bitcoin-dev/2016-May/012715.html">
          <front>
            <title>Merkle Mountain Ranges (bitcoin-dev mailing list)</title>
            <author initials="P." surname="Todd" fullname="Peter Todd">
              <organization/>
            </author>
            <date year="2016"/>
          </front>
        </reference>
        <reference anchor="KnuthTBT" target="https://www-cs-faculty.stanford.edu/~knuth/taocp.html">
          <front>
            <title>The Art of Computer Programming, Volume 1: Fundamental Algorithms, Section 2.3.1 Traversing Binary Trees</title>
            <author initials="D. E." surname="Knuth" fullname="Donald E. Knuth">
              <organization/>
            </author>
            <date>n.d.</date>
          </front>
        </reference>
      </references>
    </references>
    <?line 868?>

<section anchor="assumed-bit-primitives">
      <name>Assumed bit primitives</name>
      <section anchor="log2floor">
        <name>log2floor</name>
        <t>Returns the floor of log base 2 x</t>
        <sourcecode type="python"><![CDATA[
  def log2floor(x):
    return x.bit_length() - 1
]]></sourcecode>
      </section>
      <section anchor="mostsigbit">
        <name>most_sig_bit</name>
        <t>Returns the mask for the most significant bit in pos</t>
        <sourcecode type="python"><![CDATA[
  def most_sig_bit(pos) -> int:
    return 1 << (pos.bit_length() - 1)
]]></sourcecode>
        <t>The following primitives are assumed for working with bits as they commonly have library or hardware support.</t>
      </section>
      <section anchor="bitlength">
        <name>bit_length</name>
        <t>The minimum number of bits to represent pos. b011 would be 2, b010 would be 2, and b001 would be 1.</t>
        <sourcecode type="python"><![CDATA[
  def bit_length(pos):
    return pos.bit_length()
]]></sourcecode>
      </section>
      <section anchor="allones">
        <name>all_ones</name>
        <t>Tests if all bits, from the most significant that is set, are 1, b0111 would be true, b0101 would be false.</t>
        <sourcecode type="python"><![CDATA[
  def all_ones(pos) -> bool:
    # most_sig_bit returns a mask, so shifting it left by one
    # and subtracting one sets every bit below and including it
    mask = (most_sig_bit(pos) << 1) - 1
    return pos == mask
]]></sourcecode>
      </section>
      <section anchor="onescount">
        <name>ones_count</name>
        <t>Count of set bits.
For example <tt>ones_count(b101)</tt> is 2</t>
      </section>
      <section anchor="trailingzeros">
        <name>trailing_zeros</name>
        <sourcecode type="python"><![CDATA[
  (v & -v).bit_length() - 1
]]></sourcecode>
      </section>
    </section>
    <section anchor="acknowledgments">
      <name>Acknowledgments</name>
    </section>
  </back>
  <!-- ##markdown-source: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-->

</rfc>
