@ocash/sdk 0.1.3 → 0.1.4-rc.1

package/dist/node.js

@@ -7189,15 +7189,17 @@ var MerkleEngine = class _MerkleEngine {
         for (let i = 0; i < sorted.length; i++) {
           if (sorted[i].cid !== i) throw new Error(`Non-contiguous persisted merkle leaves: expected cid=${i}, got cid=${sorted[i].cid}`);
         }
-        const totalElements = BigInt(sorted.length);
-        const mergedElements = _MerkleEngine.totalElementsInTree(totalElements);
+        const storedTree = await this.storage?.getMerkleTree?.(chainId);
+        const leafCount = sorted.length;
+        const mergedFromLeaves = _MerkleEngine.totalElementsInTree(BigInt(leafCount));
+        const mergedFromTree = typeof storedTree?.totalElements === "number" && storedTree.totalElements > 0 ? storedTree.totalElements : 0;
+        const mergedElements = Math.max(mergedFromLeaves, mergedFromTree);
         const pending = this.ensurePendingLeaves(chainId);
         pending.length = 0;
         state.mergedElements = mergedElements;
-        if (sorted.length > mergedElements) {
+        if (leafCount > mergedElements) {
           pending.push(...sorted.slice(mergedElements).map((l) => l.commitment));
         }
-        const storedTree = await this.storage?.getMerkleTree?.(chainId);
         if (storedTree?.root) {
           state.root = _MerkleEngine.normalizeHex32(storedTree.root, "merkleTree.root");
         } else {
@@ -7247,7 +7249,10 @@ var MerkleEngine = class _MerkleEngine {
     if (!leaves.length) return;
     const sorted = [...leaves].sort((a, b) => a.index - b.index);
     const persistLeaves = sorted.map((l) => ({ cid: l.index, commitment: l.commitment }));
-    void this.storage?.appendMerkleLeaves?.(chainId, persistLeaves).catch(() => void 0);
+    try {
+      await this.storage?.appendMerkleLeaves?.(chainId, persistLeaves);
+    } catch {
+    }
     try {
       let expected = state.mergedElements + pending.length;
       for (const leaf of sorted) {
@@ -7289,6 +7294,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.
    */