@forestrie/merklelog 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -22,6 +22,6 @@ export { bagPeaks, calculateRoot, verifyInclusion, verifyConsistency, consistent
 export { createSyncHasher } from "./mmr/algorithms-sync.js";
 export type { Proof, Peak } from "./mmr/types.js";
 export type { Hasher } from "./mmr/types.js";
-export { inclusionProof, peakMMRIndexes, peaksBitmap, peakIndexForLeafProof, indexHeight, firstMMRSize, massifIndexFromMMRIndex, peakStackMap, } from "./mmr/proof.js";
-export type { NodeGetter } from "./mmr/proof.js";
+export { inclusionProof, inclusionProofPath, inclusionProofLocalExtend, peakMMRIndexes, peaksBitmap, peakIndexForLeafProof, indexHeight, firstMMRSize, massifIndexFromMMRIndex, peakStackMap, } from "./mmr/proof.js";
+export type { NodeGetter, ConsistencyProofLocal } from "./mmr/proof.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EACV,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,SAAS,GACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,SAAS,EACT,KAAK,EACL,KAAK,EACL,OAAO,EACP,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,6BAA6B,EAC7B,6BAA6B,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChF,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG3E,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EACL,WAAW,EACX,MAAM,EACN,qBAAqB,EACrB,SAAS,EACT,WAAW,EACX,sBAAsB,EACtB,SAAS,EACT,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,QAAQ,EACR,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAClD,YAAY,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAG7C,OAAO,EACL,cAAc,EACd,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EACV,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,SAAS,GACV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EACL,SAAS,EACT,KAAK,EACL,KAAK,EACL,OAAO,EACP,wBAAwB,EACxB,cAAc,EACd,YAAY,EACZ,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,6BAA6B,EAC7B,6BAA6B,EAC7B,oBAAoB,EACpB,uBAAuB,EACvB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAGvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAG9D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChF,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAG3E,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EACL,WAAW,EACX,MAAM,EACN,qBAAqB,EACrB,SAAS,EACT,WAAW,EACX,sBAAsB,EACtB,SAAS,EACT,wBAAwB,GACzB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,QAAQ,EACR,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAClD,YAAY,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAG7C,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,yBAAyB,EACzB,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,WAAW,EACX,YAAY,EACZ,uBAAuB,EACvB,YAAY,GACb,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -23,4 +23,4 @@ export { heightIndex, height, mmrIndexFromLeafIndex, leafIndex, mmrPosition, mmr
 export { bagPeaks, calculateRoot, verifyInclusion, verifyConsistency, consistentRoots, indexConsistencyProof, } from "./mmr/algorithms.js";
 export { createSyncHasher } from "./mmr/algorithms-sync.js";
 // MMR proof building (pure; store-agnostic) — plan-2607-15 §4 (go: mmr/proof.go, peaks.go)
-export { inclusionProof, peakMMRIndexes, peaksBitmap, peakIndexForLeafProof, indexHeight, firstMMRSize, massifIndexFromMMRIndex, peakStackMap, } from "./mmr/proof.js";
+export { inclusionProof, inclusionProofPath, inclusionProofLocalExtend, peakMMRIndexes, peaksBitmap, peakIndexForLeafProof, indexHeight, firstMMRSize, massifIndexFromMMRIndex, peakStackMap, } from "./mmr/proof.js";

package/dist/mmr/proof.d.ts

@@ -24,6 +24,44 @@ export declare function indexHeight(i: bigint): number;
  * @throws if `i > mmrLastIndex`.
  */
 export declare function inclusionProof(get: NodeGetter, mmrLastIndex: bigint, i: bigint): Uint8Array[];
+/**
+ * The sibling *indices* of an inclusion proof for the node at MMR index `i` in
+ * the tree ending at `mmrLastIndex` — the index-only counterpart of
+ * {@link inclusionProof} (go-merklelog `mmr/proof.go` InclusionProofPath). The
+ * values at these indices, in order, are the proof. Store-free: pure position
+ * arithmetic, so a caller can assemble a proof's node values from any source
+ * (a receipt path, consistency-proof paths, tiles).
+ */
+export declare function inclusionProofPath(mmrLastIndex: bigint, i: bigint): bigint[];
+/**
+ * An inclusion proof that has been extended from MMR size A to size B: the size-B
+ * proof is an *extension* of the size-A proof, sharing its first `heightA`
+ * elements. (go-merklelog `mmr/proofrefresh.go` ConsistencyProofLocal.)
+ */
+export type ConsistencyProofLocal = {
+    /** The node (leaf) MMR index being proven. */
+    logIndex: bigint;
+    /** Full inclusion path at size B; `path[0..heightA]` is the size-A proof. */
+    path: Uint8Array[];
+    sizeA: bigint;
+    /** Peak (root) index covering `logIndex` at size A. */
+    peakIndexA: bigint;
+    /** Length of the shared prefix — the size-A proof; the rest extends it. */
+    heightA: number;
+    sizeB: bigint;
+    /** Peak (root) index covering `logIndex` at size B. */
+    peakIndexB: bigint;
+};
+/**
+ * Extend the inclusion proof for node `i` from MMR size A to size B, reading
+ * sibling values from `get`. The result's `path` proves `i` at size B and shares
+ * its first `heightA` elements with the size-A proof — so a stale receipt's
+ * path (leaf → its old peak) is exactly `path[0..heightA]`, and the remainder is
+ * the tile-free extension. Direct port of go-merklelog `InclusionProofLocalExtend`.
+ *
+ * @throws if `mmrSizeB <= mmrSizeA`.
+ */
+export declare function inclusionProofLocalExtend(get: NodeGetter, mmrSizeA: bigint, mmrSizeB: bigint, i: bigint): ConsistencyProofLocal;
 /**
  * Peaks bitmap for an MMR size: the numeric value equals the leaf count of the
  * largest valid MMR with size <= `mmrSize`; each set bit marks a perfect

package/dist/mmr/proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../src/mmr/proof.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uEAAuE;AACvE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;AA2CnD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,UAAU,EACf,YAAY,EAAE,MAAM,EACpB,CAAC,EAAE,MAAM,GACR,UAAU,EAAE,CAyBd;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnD;AAaD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CAIR;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAczD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,CAAC,EAAE,MAAM,GACR,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAWrB"}
+{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../src/mmr/proof.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,uEAAuE;AACvE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,UAAU,CAAC;AA2CnD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,UAAU,EACf,YAAY,EAAE,MAAM,EACpB,CAAC,EAAE,MAAM,GACR,UAAU,EAAE,CAyBd;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB5E;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,CAAC,EAAE,MAAM,GACR,qBAAqB,CA4CvB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAcnD;AAaD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CAIR;AAQD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAczD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EACpB,CAAC,EAAE,MAAM,GACR,MAAM,CAKR;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAWrB"}

package/dist/mmr/proof.js

@@ -89,6 +89,89 @@ export function inclusionProof(get, mmrLastIndex, i) {
         g += 1n;
     }
 }
+/**
+ * The sibling *indices* of an inclusion proof for the node at MMR index `i` in
+ * the tree ending at `mmrLastIndex` — the index-only counterpart of
+ * {@link inclusionProof} (go-merklelog `mmr/proof.go` InclusionProofPath). The
+ * values at these indices, in order, are the proof. Store-free: pure position
+ * arithmetic, so a caller can assemble a proof's node values from any source
+ * (a receipt path, consistency-proof paths, tiles).
+ */
+export function inclusionProofPath(mmrLastIndex, i) {
+    let g = BigInt(indexHeight(i));
+    const proof = [];
+    for (;;) {
+        const siblingOffset = 2n << g;
+        let iSibling;
+        if (BigInt(indexHeight(i + 1n)) > g) {
+            iSibling = i - siblingOffset + 1n;
+            i += 1n;
+        }
+        else {
+            iSibling = i + siblingOffset - 1n;
+            i += siblingOffset;
+        }
+        if (iSibling > mmrLastIndex) {
+            return proof;
+        }
+        proof.push(iSibling);
+        g += 1n;
+    }
+}
+/**
+ * Extend the inclusion proof for node `i` from MMR size A to size B, reading
+ * sibling values from `get`. The result's `path` proves `i` at size B and shares
+ * its first `heightA` elements with the size-A proof — so a stale receipt's
+ * path (leaf → its old peak) is exactly `path[0..heightA]`, and the remainder is
+ * the tile-free extension. Direct port of go-merklelog `InclusionProofLocalExtend`.
+ *
+ * @throws if `mmrSizeB <= mmrSizeA`.
+ */
+export function inclusionProofLocalExtend(get, mmrSizeA, mmrSizeB, i) {
+    if (mmrSizeB <= mmrSizeA) {
+        throw new Error(`mmrSizeB (${mmrSizeB}) must be greater than mmrSizeA (${mmrSizeA})`);
+    }
+    const logIndex = i;
+    const path = [];
+    let height = 0n;
+    let prevComplete = false;
+    let peakIndexA = 0n;
+    let heightA = 0;
+    while (i < mmrSizeB) {
+        const siblingOffset = (2n << height) - 1n; // go-merklelog SiblingOffset
+        let iSibling;
+        let delta;
+        if (BigInt(indexHeight(i + 1n)) > BigInt(indexHeight(i))) {
+            iSibling = i - siblingOffset;
+            delta = 1n;
+        }
+        else {
+            iSibling = i + siblingOffset;
+            delta = 2n << height;
+        }
+        // The first sibling that lies outside MMR(A) marks the end of the size-A
+        // proof: `i` is the size-A covering peak and the prefix so far is its proof.
+        if (iSibling >= mmrSizeA && !prevComplete) {
+            peakIndexA = i;
+            heightA = path.length;
+            prevComplete = true;
+        }
+        if (iSibling >= mmrSizeB)
+            break;
+        path.push(get(iSibling));
+        i += delta;
+        height += 1n;
+    }
+    return {
+        logIndex,
+        path,
+        sizeA: mmrSizeA,
+        peakIndexA,
+        heightA,
+        sizeB: mmrSizeB,
+        peakIndexB: i,
+    };
+}
 /**
  * Peaks bitmap for an MMR size: the numeric value equals the leaf count of the
  * largest valid MMR with size <= `mmrSize`; each set bit marks a perfect

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestrie/merklelog",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "description": "MMR (merkle mountain range) proofs and massif storage format for Forestrie transparency logs",

package/src/index.ts

@@ -81,6 +81,8 @@ export type { Hasher } from "./mmr/types.js";
 // MMR proof building (pure; store-agnostic) — plan-2607-15 §4 (go: mmr/proof.go, peaks.go)
 export {
   inclusionProof,
+  inclusionProofPath,
+  inclusionProofLocalExtend,
   peakMMRIndexes,
   peaksBitmap,
   peakIndexForLeafProof,
@@ -89,4 +91,4 @@ export {
   massifIndexFromMMRIndex,
   peakStackMap,
 } from "./mmr/proof.js";
-export type { NodeGetter } from "./mmr/proof.js";
+export type { NodeGetter, ConsistencyProofLocal } from "./mmr/proof.js";

package/src/mmr/proof.ts

@@ -100,6 +100,115 @@ export function inclusionProof(
   }
 }
 
+/**
+ * The sibling *indices* of an inclusion proof for the node at MMR index `i` in
+ * the tree ending at `mmrLastIndex` — the index-only counterpart of
+ * {@link inclusionProof} (go-merklelog `mmr/proof.go` InclusionProofPath). The
+ * values at these indices, in order, are the proof. Store-free: pure position
+ * arithmetic, so a caller can assemble a proof's node values from any source
+ * (a receipt path, consistency-proof paths, tiles).
+ */
+export function inclusionProofPath(mmrLastIndex: bigint, i: bigint): bigint[] {
+  let g = BigInt(indexHeight(i));
+  const proof: bigint[] = [];
+  for (;;) {
+    const siblingOffset = 2n << g;
+    let iSibling: bigint;
+    if (BigInt(indexHeight(i + 1n)) > g) {
+      iSibling = i - siblingOffset + 1n;
+      i += 1n;
+    } else {
+      iSibling = i + siblingOffset - 1n;
+      i += siblingOffset;
+    }
+    if (iSibling > mmrLastIndex) {
+      return proof;
+    }
+    proof.push(iSibling);
+    g += 1n;
+  }
+}
+
+/**
+ * An inclusion proof that has been extended from MMR size A to size B: the size-B
+ * proof is an *extension* of the size-A proof, sharing its first `heightA`
+ * elements. (go-merklelog `mmr/proofrefresh.go` ConsistencyProofLocal.)
+ */
+export type ConsistencyProofLocal = {
+  /** The node (leaf) MMR index being proven. */
+  logIndex: bigint;
+  /** Full inclusion path at size B; `path[0..heightA]` is the size-A proof. */
+  path: Uint8Array[];
+  sizeA: bigint;
+  /** Peak (root) index covering `logIndex` at size A. */
+  peakIndexA: bigint;
+  /** Length of the shared prefix — the size-A proof; the rest extends it. */
+  heightA: number;
+  sizeB: bigint;
+  /** Peak (root) index covering `logIndex` at size B. */
+  peakIndexB: bigint;
+};
+
+/**
+ * Extend the inclusion proof for node `i` from MMR size A to size B, reading
+ * sibling values from `get`. The result's `path` proves `i` at size B and shares
+ * its first `heightA` elements with the size-A proof — so a stale receipt's
+ * path (leaf → its old peak) is exactly `path[0..heightA]`, and the remainder is
+ * the tile-free extension. Direct port of go-merklelog `InclusionProofLocalExtend`.
+ *
+ * @throws if `mmrSizeB <= mmrSizeA`.
+ */
+export function inclusionProofLocalExtend(
+  get: NodeGetter,
+  mmrSizeA: bigint,
+  mmrSizeB: bigint,
+  i: bigint,
+): ConsistencyProofLocal {
+  if (mmrSizeB <= mmrSizeA) {
+    throw new Error(
+      `mmrSizeB (${mmrSizeB}) must be greater than mmrSizeA (${mmrSizeA})`,
+    );
+  }
+  const logIndex = i;
+  const path: Uint8Array[] = [];
+  let height = 0n;
+  let prevComplete = false;
+  let peakIndexA = 0n;
+  let heightA = 0;
+  while (i < mmrSizeB) {
+    const siblingOffset = (2n << height) - 1n; // go-merklelog SiblingOffset
+    let iSibling: bigint;
+    let delta: bigint;
+    if (BigInt(indexHeight(i + 1n)) > BigInt(indexHeight(i))) {
+      iSibling = i - siblingOffset;
+      delta = 1n;
+    } else {
+      iSibling = i + siblingOffset;
+      delta = 2n << height;
+    }
+    // The first sibling that lies outside MMR(A) marks the end of the size-A
+    // proof: `i` is the size-A covering peak and the prefix so far is its proof.
+    if (iSibling >= mmrSizeA && !prevComplete) {
+      peakIndexA = i;
+      heightA = path.length;
+      prevComplete = true;
+    }
+    if (iSibling >= mmrSizeB) break;
+    path.push(get(iSibling));
+    i += delta;
+    height += 1n;
+  }
+  return {
+    logIndex,
+    path,
+    sizeA: mmrSizeA,
+    peakIndexA,
+    heightA,
+    sizeB: mmrSizeB,
+    peakIndexB: i,
+  };
+}
+
 /**
  * Peaks bitmap for an MMR size: the numeric value equals the leaf count of the
  * largest valid MMR with size <= `mmrSize`; each set bit marks a perfect