@tokamak-private-dapps/private-state-cli 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.5 - 2026-04-28
+
+- Switched channel balance proof generation to invoke `tokamak-groth16 --prove` instead of importing Groth16 proof internals directly.
+- Read proof artifacts from the fixed Groth16 runtime workspace manifest.
+
+## 0.1.4 - 2026-04-28
+
+- Paced chunked log recovery queries at five requests per second to avoid RPC throughput bursts.
+- Combined channel manager recovery log scans and filtered wallet note recovery scans to reduce RPC usage.
+
 ## 0.1.3 - 2026-04-28
 
 - Installed the Groth16 runtime during `private-state-cli --install` and reported Groth16 readiness from `--doctor`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokamak-private-dapps/private-state-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Command-line client for the Tokamak private-state DApp.",
   "license": "MIT OR Apache-2.0",
   "author": "Tokamak Network",
@@ -43,7 +43,7 @@
     "@ethereumjs/util": "^10.1.1",
     "@noble/curves": "^1.2.0",
     "@tokamak-private-dapps/common-library": "^0.1.0",
-    "@tokamak-private-dapps/groth16": "^0.1.0",
+    "@tokamak-private-dapps/groth16": "^0.1.1",
     "@tokamak-zk-evm/cli": "^2.0.8",
     "ethers": "^6.14.1",
     "tokamak-l2js": "^0.1.3"

package/private-state-bridge-cli.mjs

@@ -67,7 +67,6 @@ import {
   PUBLIC_GROTH16_MPC_DRIVE_FOLDER_ID,
   downloadLatestPublicGroth16MpcArtifacts,
 } from "@tokamak-private-dapps/groth16/public-drive-crs";
-import { main as generateUpdateTreeProof } from "@tokamak-private-dapps/groth16/prover/updateTree/generateProof";
 import {
   CHANNEL_BOUND_L2_DERIVATION_MODE,
   deriveChannelIdFromName,
@@ -152,6 +151,9 @@ const JUBJUB_D = jubjub.CURVE.d;
 const BLS12_381_SCALAR_FIELD_MODULUS =
   hexToBigInt(addHexPrefix("73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001"));
 const DEFAULT_LOG_CHUNK_SIZE = 2000;
+const DEFAULT_LOG_REQUESTS_PER_SECOND = 5;
+const LOG_REQUEST_INTERVAL_MS = Math.ceil(1000 / DEFAULT_LOG_REQUESTS_PER_SECOND);
+let lastLogRequestStartedAtMs = 0;
 
 async function prepareDeploymentArtifacts(chainId) {
   const normalizedChainId = Number(chainId);
@@ -2030,6 +2032,7 @@ async function recoverDeliveredNotesFromEventLogs({
   const nullifierUsedSlot = ethers.toBigInt(findStorageSlot(storageLayoutManifest, "PrivateStateController", "nullifierUsed"));
   const observedLogs = await fetchLogsChunked(provider, {
     address: context.workspace.channelManager,
+    topics: [NOTE_VALUE_ENCRYPTED_TOPIC],
     fromBlock: scanStartBlock,
     toBlock: latestBlock,
   });
@@ -3453,10 +3456,7 @@ async function buildGrothTransition({ operationDir, workspace, stateManager, vau
 
   const inputPath = path.join(operationDir, "input.json");
   writeJson(inputPath, input);
-  const proofManifest = await generateUpdateTreeProof([
-    "--input",
-    inputPath,
-  ]);
+  const proofManifest = runGroth16UpdateTreeProof(inputPath);
 
   const proofJson = readJson(proofManifest.proofPath);
   const publicSignals = readJson(proofManifest.publicPath);
@@ -3503,6 +3503,21 @@ function runCaptured(command, args, { cwd = defaultCommandCwd, env = process.env
   };
 }
 
+function runGroth16UpdateTreeProof(inputPath) {
+  const packageRoot = resolveGroth16PackageRoot();
+  const entryPath = resolveGroth16CliEntryPath(packageRoot);
+  run(process.execPath, [entryPath, "--prove", inputPath], { cwd: packageRoot });
+  const manifestPath = groth16ProofManifestPath();
+  const manifest = readJson(manifestPath);
+  expect(typeof manifest.proofPath === "string" && manifest.proofPath.length > 0, "Groth16 proof manifest is missing proofPath.");
+  expect(typeof manifest.publicPath === "string" && manifest.publicPath.length > 0, "Groth16 proof manifest is missing publicPath.");
+  return manifest;
+}
+
+function groth16ProofManifestPath() {
+  return path.join(os.homedir(), "tokamak-private-channels", "groth16", "proof", "proof-manifest.json");
+}
+
 function runTokamakProofPipeline({ operationDir, bundlePath }) {
   runTokamakCliStage({
     operationDir,
@@ -3854,30 +3869,39 @@ async function reconstructChannelSnapshot({
     provider,
   );
   const latestBlock = await provider.getBlockNumber();
-  const rootEvents = await queryContractEventsChunked({
-    contract: channelManager,
-    eventName: "CurrentRootVectorObserved",
+  const currentRootVectorObservedTopic =
+    normalizeBytes32Hex(channelManager.interface.getEvent("CurrentRootVectorObserved").topicHash);
+  const channelManagerLogs = await fetchLogsChunked(provider, {
+    address: channelInfo.manager,
+    topics: [[
+      currentRootVectorObservedTopic,
+      CONTROLLER_STORAGE_KEY_OBSERVED_TOPIC,
+      VAULT_STORAGE_WRITE_OBSERVED_TOPIC,
+    ]],
     fromBlock: genesisBlockNumber,
     toBlock: latestBlock,
   });
+  const channelManagerEvents = channelManagerLogs.map((log) => {
+    const topic0 = log.topics[0] ? normalizeBytes32Hex(log.topics[0]) : null;
+    if (topic0 !== null && ethers.toBigInt(topic0) === ethers.toBigInt(currentRootVectorObservedTopic)) {
+      const parsed = channelManager.interface.parseLog(log);
+      return {
+        ...log,
+        args: parsed.args,
+        fragment: parsed.fragment,
+      };
+    }
+    return log;
+  });
   const vaultStorageWriteEvents = await queryContractEventsChunked({
     contract: bridgeTokenVault,
     eventName: "StorageWriteObserved",
     fromBlock: genesisBlockNumber,
     toBlock: latestBlock,
   });
-  const observedStorageLogs = await fetchLogsChunked(provider, {
-    address: channelInfo.manager,
-    topics: [[
-      CONTROLLER_STORAGE_KEY_OBSERVED_TOPIC,
-      VAULT_STORAGE_WRITE_OBSERVED_TOPIC,
-    ]],
-    fromBlock: genesisBlockNumber,
-    toBlock: latestBlock,
-  });
 
   const groupedEvents = new Map();
-  for (const event of [...rootEvents, ...vaultStorageWriteEvents, ...observedStorageLogs]) {
+  for (const event of [...channelManagerEvents, ...vaultStorageWriteEvents]) {
     const key = event.transactionHash;
     const group = groupedEvents.get(key) ?? [];
     group.push(event);
@@ -4000,6 +4024,7 @@ async function fetchLogsChunked(provider, {
   while (cursor <= resolvedToBlock) {
     const chunkToBlock = Math.min(resolvedToBlock, cursor + chunkSize - 1);
     try {
+      await throttleLogRequest();
       const logs = await provider.getLogs({
         address,
         topics,
@@ -4009,6 +4034,12 @@ async function fetchLogsChunked(provider, {
       aggregatedLogs.push(...logs);
       cursor = chunkToBlock + 1;
     } catch (error) {
+      if (isRateLimitError(error)) {
+        throw new Error(
+          `RPC log query rate limit exceeded. Log chunk requests are paced at ${DEFAULT_LOG_REQUESTS_PER_SECOND} requests per second.`,
+          { cause: error },
+        );
+      }
       const suggestedChunkSize = deriveRecommendedLogChunkSize(error, chunkSize);
       if (suggestedChunkSize >= chunkSize) {
         throw error;
@@ -4020,6 +4051,31 @@ async function fetchLogsChunked(provider, {
   return aggregatedLogs;
 }
 
+async function throttleLogRequest() {
+  const elapsedMs = Date.now() - lastLogRequestStartedAtMs;
+  if (elapsedMs < LOG_REQUEST_INTERVAL_MS) {
+    await sleep(LOG_REQUEST_INTERVAL_MS - elapsedMs);
+  }
+  lastLogRequestStartedAtMs = Date.now();
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isRateLimitError(error) {
+  const serializedError = [
+    error?.code,
+    error?.status,
+    error?.message,
+    error?.shortMessage,
+    error?.info?.responseStatus,
+    error?.info?.responseBody,
+  ].filter((value) => value !== undefined && value !== null).join("\n");
+
+  return /\b429\b|too many requests|rate limit|compute units/i.test(serializedError);
+}
+
 function deriveRecommendedLogChunkSize(error, currentChunkSize) {
   const serializedError = [
     error?.message,