@ocash/sdk 0.1.4-rc.0 → 0.1.4-rc.1

package/dist/browser.cjs

@@ -7362,6 +7362,90 @@ var MerkleEngine = class _MerkleEngine {
       throw new SdkError("MERKLE", "Failed to ingest local merkle leaves", { chainId, leafCount: leaves.length }, error);
     }
   }
+  /**
+   * Roll back the local Merkle tree to a previous checkpoint.
+   *
+   * Reconstructs correct frontier state by replaying merges from stored subtree
+   * roots (level-5 nodes). Cost: O(batches × depth) where batches = target / 32.
+   *
+   * @param targetMergedElements Must be a non-negative multiple of 32 (SUBTREE_SIZE).
+   *   Pass 0 to reset to the empty tree.
+   * @returns true if rollback succeeded, false if required data (checkpoint or
+   *   subtree roots) is missing in storage.
+   */
+  async rollbackTree(chainId, targetMergedElements) {
+    if (targetMergedElements < 0 || targetMergedElements % SUBTREE_SIZE !== 0) {
+      throw new SdkError("MERKLE", "rollbackTree target must be a non-negative multiple of 32", { targetMergedElements });
+    }
+    const state = this.ensureChainState(chainId);
+    const pending = this.ensurePendingLeaves(chainId);
+    if (targetMergedElements === 0) {
+      state.mergedElements = 0;
+      state.root = getZeroHash(this.treeDepth);
+      pending.length = 0;
+      await this.storage?.setMerkleTree?.(chainId, {
+        chainId,
+        root: state.root,
+        totalElements: 0,
+        lastUpdated: Date.now()
+      });
+      return true;
+    }
+    const checkpoint = await this.storage?.getMerkleNode?.(chainId, `checkpoint-${targetMergedElements}`);
+    if (!checkpoint) return false;
+    const numBatches = targetMergedElements / SUBTREE_SIZE;
+    const subtreeRoots = [];
+    for (let batch = 0; batch < numBatches; batch++) {
+      const node = await this.storage?.getMerkleNode?.(chainId, `${SUBTREE_DEPTH}-${batch}`);
+      if (!node) return false;
+      subtreeRoots.push(node.hash);
+    }
+    const resetNodes = [];
+    for (let level = SUBTREE_DEPTH; level < this.treeDepth; level++) {
+      resetNodes.push({
+        chainId,
+        id: `frontier-${level}`,
+        level,
+        position: 0,
+        hash: getZeroHash(level)
+      });
+    }
+    await this.storage?.upsertMerkleNodes?.(chainId, resetNodes);
+    let replayRoot = getZeroHash(this.treeDepth);
+    for (let batch = 0; batch < numBatches; batch++) {
+      const merged = await this.mergeSubtreeToMainTree({
+        chainId,
+        subtreeRoot: subtreeRoots[batch],
+        newTotalElements: (batch + 1) * SUBTREE_SIZE
+      });
+      replayRoot = merged.finalRoot;
+      await this.storage?.upsertMerkleNodes?.(chainId, merged.nodesToStore.map((n) => ({ ...n, chainId })));
+    }
+    const replayNorm = _MerkleEngine.normalizeHex32(replayRoot, "replay.root");
+    const checkpointNorm = _MerkleEngine.normalizeHex32(checkpoint.hash, "checkpoint.root");
+    if (replayNorm !== checkpointNorm) {
+      return false;
+    }
+    state.mergedElements = targetMergedElements;
+    state.root = checkpointNorm;
+    pending.length = 0;
+    this.hydratedChains.add(chainId);
+    await this.storage?.setMerkleTree?.(chainId, {
+      chainId,
+      root: state.root,
+      totalElements: targetMergedElements,
+      lastUpdated: Date.now()
+    });
+    const updatedCheckpoint = {
+      chainId,
+      id: `checkpoint-${targetMergedElements}`,
+      level: -1,
+      position: 0,
+      hash: checkpointNorm
+    };
+    await this.storage?.upsertMerkleNodes?.(chainId, [updatedCheckpoint]);
+    return true;
+  }
   /**
    * Convenience wrapper to request a single proof.
    */