@unlink-xyz/core 0.1.3-canary.f82115c → 0.1.3-canary.fd5dddf

package/dist/browser/index.js

@@ -75263,82 +75263,6 @@ var init_fs = __esm({
 init_process();
 init_buffer();
 
-// circuits.json
-var circuits_default = {
-  joinsplit_1x1_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [1, 1, 16]
-  },
-  joinsplit_1x2_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [1, 2, 16]
-  },
-  joinsplit_2x1_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [2, 1, 16]
-  },
-  joinsplit_2x2_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [2, 2, 16]
-  },
-  joinsplit_2x3_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [2, 3, 16]
-  },
-  joinsplit_3x1_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [3, 1, 16]
-  },
-  joinsplit_3x2_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [3, 2, 16]
-  },
-  joinsplit_3x3_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [3, 3, 16]
-  },
-  joinsplit_4x1_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [4, 1, 16]
-  },
-  joinsplit_4x2_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [4, 2, 16]
-  },
-  joinsplit_5x1_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [5, 1, 16]
-  },
-  joinsplit_5x2_16: {
-    file: "joinsplit",
-    template: "JoinSplit",
-    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
-    params: [5, 2, 16]
-  }
-};
-
 // constants.ts
 init_process();
 init_buffer();
@@ -75622,7 +75546,7 @@ function createIndexedDbStorage(opts = {}) {
       } catch (err2) {
         try {
           tx.abort();
-        } catch (_) {
+        } catch {
         }
         await done.catch(() => {
         });
@@ -78084,7 +78008,7 @@ function encodeJson(value) {
 function decodeJson(payload) {
   try {
     return JSON.parse(decoder.decode(payload));
-  } catch (err2) {
+  } catch {
     throw new CoreError("failed to decode stored state payload");
   }
 }
@@ -78536,6 +78460,36 @@ function createNullifierStore(storage) {
       const prefix = `nullifiers:${chainId}:`;
       const entries = await storage.iter({ prefix });
       return entries.length;
+    },
+    /**
+     * Remove all cached nullifiers for a chain.
+     */
+    async clearNullifiers(chainId) {
+      const prefix = `nullifiers:${chainId}:`;
+      const entries = await storage.iter({ prefix });
+      if (entries.length === 0) return;
+      await storage.batch(entries.map(({ key: key2 }) => ({ del: key2 })));
+    },
+    /**
+     * Remove cached nullifiers whose noteIndex >= fromIndex.
+     * Used by partial resync to keep the count-based optimization accurate.
+     */
+    async clearNullifiersFromIndex(chainId, fromIndex) {
+      const prefix = `nullifiers:${chainId}:`;
+      const entries = await storage.iter({ prefix });
+      const ops = [];
+      for (const { key: key2, value } of entries) {
+        try {
+          const record = JSON.parse(
+            new TextDecoder().decode(value)
+          );
+          if (record.noteIndex === void 0 || record.noteIndex >= fromIndex) {
+            ops.push({ del: key2 });
+          }
+        } catch {
+        }
+      }
+      if (ops.length > 0) await storage.batch(ops);
     }
   };
 }
@@ -78615,6 +78569,32 @@ function createStateStore(storage) {
     }
     await storage.batch(ops);
   }
+  async function clearChainDataFromIndex(chainId, fromIndex) {
+    const prefixes = [
+      `notes:${chainId}:`,
+      `leaves:${chainId}:`,
+      `ciphertexts:${chainId}:`
+    ];
+    const ops = [];
+    for (const prefix of prefixes) {
+      const entries = await storage.iter({ prefix });
+      for (const { key: key2 } of entries) {
+        const idx = parseInt(key2.slice(key2.lastIndexOf(":") + 1), 10);
+        if (!isNaN(idx) && idx >= fromIndex) {
+          ops.push({ del: key2 });
+        }
+      }
+    }
+    const unspentPrefix = `idx:notes:unspent:${chainId}:`;
+    const unspentEntries = await storage.iter({ prefix: unspentPrefix });
+    for (const { key: key2 } of unspentEntries) {
+      const idx = parseInt(key2.slice(key2.lastIndexOf(":") + 1), 10);
+      if (!isNaN(idx) && idx >= fromIndex) {
+        ops.push({ del: key2 });
+      }
+    }
+    if (ops.length > 0) await storage.batch(ops);
+  }
   return {
     ...notes,
     ...nullifiers,
@@ -78623,7 +78603,8 @@ function createStateStore(storage) {
     ...ciphertexts,
     ...jobs,
     ...history,
-    syncCommitment
+    syncCommitment,
+    clearChainDataFromIndex
   };
 }
 
@@ -89160,7 +89141,7 @@ function createIndexerClient(baseUrl, deps) {
 // config.ts
 init_process();
 init_buffer();
-var CONFIG_URL = "https://raw.githubusercontent.com/unlink-xyz/config/main/environments.json";
+var CONFIG_URL = "https://api.unlink.xyz/config/networks.json";
 async function fetchEnvironmentConfig(env3) {
   const res = await fetch(CONFIG_URL);
   if (!res.ok) {
@@ -106387,84 +106368,96 @@ var Runtime = {
 // prover/registry.ts
 init_process();
 init_buffer();
-var CIRCUIT_REGISTRY = {
-  "1x1": {
-    name: "joinsplit_1x1_16",
-    inputs: 1,
-    outputs: 1,
-    depth: 16
+
+// ../../zk/circuits.json
+var circuits_default = {
+  joinsplit_1x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [1, 1, 16]
   },
-  "1x2": {
-    name: "joinsplit_1x2_16",
-    inputs: 1,
-    outputs: 2,
-    depth: 16
+  joinsplit_1x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [1, 2, 16]
   },
-  "2x1": {
-    name: "joinsplit_2x1_16",
-    inputs: 2,
-    outputs: 1,
-    depth: 16
+  joinsplit_2x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [2, 1, 16]
   },
-  "2x2": {
-    name: "joinsplit_2x2_16",
-    inputs: 2,
-    outputs: 2,
-    depth: 16
+  joinsplit_2x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [2, 2, 16]
   },
-  "2x3": {
-    name: "joinsplit_2x3_16",
-    inputs: 2,
-    outputs: 3,
-    depth: 16
+  joinsplit_2x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [2, 3, 16]
   },
-  "3x1": {
-    name: "joinsplit_3x1_16",
-    inputs: 3,
-    outputs: 1,
-    depth: 16
+  joinsplit_3x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [3, 1, 16]
   },
-  "3x2": {
-    name: "joinsplit_3x2_16",
-    inputs: 3,
-    outputs: 2,
-    depth: 16
+  joinsplit_3x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [3, 2, 16]
   },
-  "3x3": {
-    name: "joinsplit_3x3_16",
-    inputs: 3,
-    outputs: 3,
-    depth: 16
+  joinsplit_3x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [3, 3, 16]
   },
-  "4x1": {
-    name: "joinsplit_4x1_16",
-    inputs: 4,
-    outputs: 1,
-    depth: 16
+  joinsplit_4x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [4, 1, 16]
   },
-  "4x2": {
-    name: "joinsplit_4x2_16",
-    inputs: 4,
-    outputs: 2,
-    depth: 16
+  joinsplit_4x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [4, 2, 16]
   },
-  "5x1": {
-    name: "joinsplit_5x1_16",
-    inputs: 5,
-    outputs: 1,
-    depth: 16
+  joinsplit_5x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [5, 1, 16]
   },
-  "5x2": {
-    name: "joinsplit_5x2_16",
-    inputs: 5,
-    outputs: 2,
-    depth: 16
+  joinsplit_5x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [5, 2, 16]
   }
 };
+
+// prover/registry.ts
+var registry = {};
+for (const [name, def] of Object.entries(circuits_default)) {
+  const params = def.params;
+  const inputs = params[0];
+  const outputs = params[1];
+  const depth = params[2];
+  registry[`${inputs}x${outputs}`] = { name, inputs, outputs, depth };
+}
+var CIRCUIT_REGISTRY = registry;
 var SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY);
 function getCircuitConfig(inputs, outputs) {
-  const key2 = `${inputs}x${outputs}`;
-  return key2 in CIRCUIT_REGISTRY ? CIRCUIT_REGISTRY[key2] : void 0;
+  return CIRCUIT_REGISTRY[`${inputs}x${outputs}`];
 }
 
 // prover/prover.ts
@@ -106848,8 +106841,9 @@ async function transact(store, req, opts) {
       merkleRoot: parseHexToBigInt(r3.merkleRoot),
       nullifierHashes: r3.contexts.map((c) => c.nullifier),
       newCommitments: r3.proof.pubSignals.slice(
-        2 + r3.contexts.length
+        2 + r3.contexts.length,
         // Skip root + boundParams + nullifiers
+        r3.withdrawal.amount > 0n ? r3.proof.pubSignals.length - 1 : void 0
       ),
       context: { chainId: BigInt(req.chainId), poolAddress: req.poolAddress },
       withdrawal: r3.withdrawal,
@@ -107734,12 +107728,71 @@ function createNoteSyncService(stateStore, options = {}) {
       }
     }
   }
+  async function diagnoseChainState(chainId, localCount) {
+    const firstBatch = await indexerClient.fetchCommitmentBatch({
+      chainId,
+      start: 0,
+      limit: 1
+    });
+    const localFirst = await stateStore.getLeaf(chainId, 0);
+    if (firstBatch.commitments.length === 0 || !localFirst) {
+      return { kind: "full-divergence" };
+    }
+    if (firstBatch.commitments[0].commitment !== localFirst.commitment) {
+      return { kind: "full-divergence" };
+    }
+    if (localCount === 1) {
+      return { kind: "consistent" };
+    }
+    const lastBatch = await indexerClient.fetchCommitmentBatch({
+      chainId,
+      start: localCount - 1,
+      limit: 1
+    });
+    const localLast = await stateStore.getLeaf(chainId, localCount - 1);
+    if (lastBatch.commitments.length > 0 && localLast && lastBatch.commitments[0].commitment === localLast.commitment) {
+      return { kind: "consistent" };
+    }
+    const divergePoint = await findDivergencePoint(chainId, 1, localCount - 1);
+    return { kind: "partial-divergence", validPrefix: divergePoint };
+  }
+  async function findDivergencePoint(chainId, low, high) {
+    while (low < high) {
+      const mid = Math.floor((low + high) / 2);
+      const batch = await indexerClient.fetchCommitmentBatch({
+        chainId,
+        start: mid,
+        limit: 1
+      });
+      const localLeaf = await stateStore.getLeaf(chainId, mid);
+      if (batch.commitments.length > 0 && localLeaf && batch.commitments[0].commitment === localLeaf.commitment) {
+        low = mid + 1;
+      } else {
+        high = mid;
+      }
+    }
+    return low;
+  }
+  async function partialResync(chainId, fromIndex, account) {
+    await Promise.all([
+      stateStore.clearChainDataFromIndex(chainId, fromIndex),
+      stateStore.clearNullifiersFromIndex(chainId, fromIndex)
+    ]);
+    trees.reset(chainId);
+    await rebuildTreeFromStore({
+      chainId,
+      trees,
+      loadLeaf: stateStore.getLeaf.bind(stateStore)
+    });
+    await ingestFrom(chainId, fromIndex, account);
+  }
   async function fullResync(chainId, account) {
     trees.reset(chainId);
     await Promise.all([
       stateStore.clearLeaves(chainId),
       stateStore.clearNotes(chainId),
-      stateStore.clearCiphertexts(chainId)
+      stateStore.clearCiphertexts(chainId),
+      stateStore.clearNullifiers(chainId)
     ]);
     await ingestFrom(chainId, 0, account);
   }
@@ -107870,10 +107923,43 @@ function createNoteSyncService(stateStore, options = {}) {
       });
       if (opts.forceFullResync) {
         await fullResync(chainId, account);
+      } else if (start > 0) {
+        try {
+          const diagnosis = await diagnoseChainState(chainId, start);
+          switch (diagnosis.kind) {
+            case "consistent":
+              try {
+                await ingestFrom(chainId, start, account);
+              } catch (err2) {
+                console.warn(
+                  `[note-sync] incremental ingest failed for chain ${chainId}, falling back to full resync:`,
+                  err2
+                );
+                await fullResync(chainId, account);
+              }
+              break;
+            case "partial-divergence":
+              await partialResync(chainId, diagnosis.validPrefix, account);
+              break;
+            case "full-divergence":
+              await fullResync(chainId, account);
+              break;
+          }
+        } catch (err2) {
+          console.warn(
+            `[note-sync] chain diagnosis failed for chain ${chainId}, falling back to full resync:`,
+            err2
+          );
+          await fullResync(chainId, account);
+        }
       } else {
         try {
-          await ingestFrom(chainId, start, account);
-        } catch {
+          await ingestFrom(chainId, 0, account);
+        } catch (err2) {
+          console.warn(
+            `[note-sync] initial ingest failed for chain ${chainId}, falling back to full resync:`,
+            err2
+          );
           await fullResync(chainId, account);
         }
       }
@@ -107934,7 +108020,6 @@ export {
   SchemaMismatchError,
   ValidationError,
   assertNonNegative,
-  circuits_default as circuitsConfig,
   computeBalances,
   computeMasterPublicKey,
   computeNullifyingKey,