@0xbow/privacy-pools-core-sdk 1.1.0 → 1.2.0

package/dist/types/index.js

@@ -1,4 +1,4 @@
-export { o as AccountError, A as AccountService, B as BlockchainProvider, p as CircuitName, k as Circuits, C as CommitmentService, n as ContractError, l as ContractInteractionsService, a as DEFAULT_LOG_FETCH_CONFIG, D as DataService, E as ErrorCode, I as InvalidRpcUrl, P as PrivacyPoolSDK, m as ProofError, S as SDKError, W as WithdrawalService, f as bigintToHash, i as bigintToHex, j as calculateContext, b as generateDepositSecrets, g as generateMasterKeys, e as generateMerkleProof, c as generateWithdrawalSecrets, d as getCommitment, h as hashPrecommitment } from './index-CH7gk4sK.js';
+export { o as AccountError, A as AccountService, B as BlockchainProvider, p as CircuitName, k as Circuits, C as CommitmentService, n as ContractError, l as ContractInteractionsService, a as DEFAULT_LOG_FETCH_CONFIG, D as DataService, E as ErrorCode, I as InvalidRpcUrl, P as PrivacyPoolSDK, m as ProofError, S as SDKError, W as WithdrawalService, f as bigintToHash, i as bigintToHex, j as calculateContext, b as generateDepositSecrets, g as generateMasterKeys, e as generateMerkleProof, c as generateWithdrawalSecrets, d as getCommitment, h as hashPrecommitment } from './index-BwyNuaY0.js';
 import 'viem/accounts';
 import 'buffer';
 import 'http';

package/dist/types/types/account.d.ts

@@ -6,6 +6,7 @@ export interface PoolAccount {
     deposit: AccountCommitment;
     children: AccountCommitment[];
     ragequit?: RagequitEvent;
+    isMigrated?: boolean;
 }
 export interface AccountCommitment {
     hash: Hash;
@@ -16,6 +17,7 @@ export interface AccountCommitment {
     blockNumber: bigint;
     timestamp?: bigint;
     txHash: Hex;
+    isMigration?: boolean;
 }
 export interface PrivacyPoolAccount {
     masterKeys: [masterNullifier: Secret, masterSecret: Secret];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xbow/privacy-pools-core-sdk",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Typescript SDK for the Privacy Pool protocol",
   "repository": "https://github.com/0xbow-io/privacy-pools-core",
   "license": "Apache-2.0",

package/src/circuits/artifactHashes.ts

@@ -0,0 +1,74 @@
+import { CircuitName, CircuitNameString } from "./circuits.interface.js";
+
+type ArtifactType = "wasm" | "vkey" | "zkey";
+
+/**
+ * Expected SHA-256 hex digests for every downloaded circuit artifact.
+ *
+ * vkey and zkey hashes are derived from the trusted-setup ceremony outputs
+ * committed in packages/circuits/trusted-setup/final-keys/.
+ *
+ * wasm hashes are derived from the compiled circuit outputs
+ * in packages/circuits/build/.
+ *
+ * Every artifact downloaded by the SDK MUST have a hash entry here.
+ * verifyArtifactIntegrity throws if a hash is missing — refusing to
+ * load unverified artifacts is the correct security posture.
+ */
+export const ARTIFACT_HASHES: Record<
+  CircuitNameString,
+  Partial<Record<ArtifactType, string>>
+> = {
+  [CircuitName.Commitment]: {
+    wasm: "254d2130607182fd6fd1aee67971526b13cfe178c88e360da96dce92663828d8",
+    vkey: "7d48b4eb3dedc12fb774348287b587f0c18c3c7254cd60e9cf0f8b3636a570d8",
+    zkey: "494ae92d64098fda2a5649690ddc5821fcd7449ca5fe8ef99ee7447544d7e1f3",
+  },
+  [CircuitName.Withdraw]: {
+    wasm: "36cda22791def3d520a55c0fc808369cd5849532a75fab65686e666ed3d55c10",
+    vkey: "666bd0983b20c1611543b04f7712e067fbe8cad69f07ada8a310837ff398d21e",
+    zkey: "2a893b42174c813566e5c40c715a8b90cd49fc4ecf384e3a6024158c3d6de677",
+  },
+  [CircuitName.MerkleTree]: {},
+};
+
+// Freeze the manifest so runtime code cannot swap out trusted hashes.
+for (const circuitHashes of Object.values(ARTIFACT_HASHES)) {
+  if (circuitHashes != null) {
+    Object.freeze(circuitHashes);
+  }
+}
+
+Object.freeze(ARTIFACT_HASHES);
+
+export async function sha256Hex(data: Uint8Array): Promise<string> {
+  const hashBuffer = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    data as ArrayBufferView<ArrayBuffer>,
+  );
+  return Array.from(new Uint8Array(hashBuffer))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+export async function verifyArtifactIntegrity(
+  circuitName: CircuitNameString,
+  artifactType: ArtifactType,
+  data: Uint8Array,
+): Promise<void> {
+  const expectedHash = ARTIFACT_HASHES[circuitName]?.[artifactType];
+  if (expectedHash === undefined) {
+    throw new Error(
+      `No integrity hash registered for ${circuitName}.${artifactType}. ` +
+        `Refusing to load unverified artifact.`,
+    );
+  }
+
+  const actualHash = await sha256Hex(data);
+  if (actualHash !== expectedHash) {
+    throw new Error(
+      `Integrity check failed for ${circuitName}.${artifactType}: ` +
+        `expected ${expectedHash}, got ${actualHash}`,
+    );
+  }
+}

package/src/circuits/circuits.impl.ts

@@ -10,6 +10,7 @@ import {
   VersionString,
 } from "./circuits.interface.js";
 import { importFetchVersionedArtifact } from "./fetchArtifacts.js";
+import { verifyArtifactIntegrity } from "./artifactHashes.js";
 
 interface CircuitOptions {
   baseUrl?: string;
@@ -141,6 +142,13 @@ export class Circuits implements CircuitsInterface {
       this._fetchVersionedArtifact(["artifacts", assetName.vkey].join("/")),
       this._fetchVersionedArtifact(["artifacts", assetName.zkey].join("/")),
     ]);
+
+    await Promise.all([
+      verifyArtifactIntegrity(circuitName, "wasm", wasm),
+      verifyArtifactIntegrity(circuitName, "vkey", vkey),
+      verifyArtifactIntegrity(circuitName, "zkey", zkey),
+    ]);
+
     return { wasm, vkey, zkey };
   }
 

package/src/core/account.service.ts

@@ -2,6 +2,7 @@ import { poseidon } from "maci-crypto/build/ts/hashing.js";
 import { Hash, Secret } from "../types/commitment.js";
 import { Hex, bytesToNumber } from "viem";
 import { mnemonicToAccount } from "viem/accounts";
+import { generateMasterKeys } from "../crypto.js";
 import { mapLimit } from "async";
 import { DataService } from "./data.service.js";
 import {
@@ -71,7 +72,7 @@ export class AccountService {
   }
 
   /**
-   * Initializes a new account from a mnemonic phrase.
+   * Initializes a new account from a mnemonic phrase for the legacy account.
    *
    * @param mnemonic - The mnemonic phrase to derive keys from
    * @returns A new PrivacyPoolAccount with derived master keys
@@ -85,9 +86,8 @@ export class AccountService {
    * @throws {AccountError} If account initialization fails
    * @private
    */
-  private _initializeAccount(mnemonic: string): PrivacyPoolAccount {
+  protected static _initializeLegacyAccount(mnemonic: string): PrivacyPoolAccount {
     try {
-      this.logger.debug("Initializing account with mnemonic");
 
       const masterNullifierSeed = bytesToNumber(
         mnemonicToAccount(mnemonic, { accountIndex: 0 }).getHdKey().privateKey!
@@ -113,6 +113,40 @@ export class AccountService {
     }
   }
 
+  /**
+   * Initializes a new account from a mnemonic phrase.
+   *
+   * @param mnemonic - The mnemonic phrase to derive keys from
+   * @returns A new PrivacyPoolAccount with derived master keys
+   *
+   * @remarks
+   * This method derives two master keys from the mnemonic:
+   * 1. A master nullifier key from account index 0
+   * 2. A master secret key from account index 1
+   * These keys are used to deterministically generate nullifiers and secrets for deposits and withdrawals.
+   *
+   * @throws {AccountError} If account initialization fails
+   * @private
+   */
+  private _initializeAccount(mnemonic: string): PrivacyPoolAccount {
+    try {
+      this.logger.debug("Initializing account with mnemonic");
+
+      const { masterNullifier, masterSecret } = generateMasterKeys(mnemonic);
+
+      return {
+        masterKeys: [masterNullifier, masterSecret],
+        poolAccounts: new Map(),
+        creationTimestamp: 0n,
+        lastUpdateTimestamp: 0n,
+      };
+    } catch (error) {
+      throw AccountError.accountInitializationFailed(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+
   /**
    * Generates a deterministic nullifier for a deposit.
    *
@@ -212,7 +246,7 @@ export class AccountService {
 
       for (const account of accounts) {
         // Skip accounts that have been ragequit
-        if (account.ragequit) {
+        if (account.ragequit || account.isMigrated) {
           continue;
         }
 
@@ -426,6 +460,75 @@ export class AccountService {
     return newCommitment;
   }
 
+  /**
+   * Adds a new commitment to the account after migrate
+   *
+   * @param parentCommitment - The commitment that was spent
+   * @param value - The remaining value after spending
+   * @param nullifier - The nullifier used for migrate
+   * @param secret - The secret used for migrate
+   * @param blockNumber - The block number of the withdrawal
+   * @param txHash - The transaction hash of the withdrawal
+   * @returns The new commitment
+   *
+   * @remarks
+   * This method finds the account containing the parent commitment, creates a new
+   * commitment with the provided parameters, and adds it to the account's children.
+   * The new commitment inherits the label from the parent commitment.
+   *
+   * @throws {AccountError} If no account is found for the commitment
+   */
+  public addMigrationCommitment(
+    parentCommitment: AccountCommitment,
+    value: bigint,
+    nullifier: Secret,
+    secret: Secret,
+    blockNumber: bigint,
+    txHash: Hex
+  ): AccountCommitment {
+    let foundAccount: PoolAccount | undefined;
+    let foundScope: bigint | undefined;
+
+    for (const [scope, accounts] of this.account.poolAccounts.entries()) {
+      foundAccount = accounts.find((account) => {
+        if (account.deposit.hash === parentCommitment.hash) return true;
+        return account.children.some(
+          (child) => child.hash === parentCommitment.hash
+        );
+      });
+
+      if (foundAccount) {
+        foundScope = scope;
+        break;
+      }
+    }
+
+    if (!foundAccount || !foundScope) {
+      throw AccountError.commitmentNotFound(parentCommitment.hash);
+    }
+
+    const precommitment = this._hashPrecommitment(nullifier, secret);
+    const newCommitment: AccountCommitment = {
+      hash: this._hashCommitment(value, parentCommitment.label, precommitment),
+      value,
+      label: parentCommitment.label,
+      nullifier,
+      secret,
+      blockNumber,
+      txHash,
+      isMigration: true
+    };
+
+    foundAccount.children.push(newCommitment);
+    foundAccount.isMigrated = true;
+
+    this.logger.info(
+      `Added new commitment with value ${value} to account with label ${parentCommitment.label}`
+    );
+
+    return newCommitment;
+  }
+
   /**
    * Adds a ragequit event to an existing pool account
    *
@@ -646,14 +749,15 @@ export class AccountService {
    */
   private _processDepositEvents(
     scope: Hash,
-    depositEvents: Map<Hash, DepositEvent>
+    depositEvents: Map<Hash, DepositEvent>,
+    startIndex: bigint = 0n,
   ): void {
     const MAX_CONSECUTIVE_MISSES = 10; // Large enough to avoid tx failures
 
     const foundIndices = new Set<bigint>();
     let consecutiveMisses = 0;
 
-    for (let index = BigInt(0); ; index++) {
+    for (let index = startIndex; ; index++) {
       // Generate nullifier, secret, and precommitment for this index
       const { nullifier, secret, precommitment } = this.createDepositSecrets(
         scope,
@@ -727,9 +831,9 @@ export class AccountService {
     // Process each account in parallel for better performance
     for (const account of accounts) {
       let currentCommitment = account.deposit;
-      let index = BigInt(0);
+      let index = BigInt(account.children.length);
 
-      // Continue processing withdrawals until no more are found secuentially
+      // Continue processing withdrawals until no more are found sequentially
       while (true) {
         // Generate nullifier for this withdrawal
         const nullifierHash = poseidon([currentCommitment.nullifier]) as Hash;
@@ -740,22 +844,48 @@ export class AccountService {
           break;
         }
 
+        const remainingValue = currentCommitment.value - withdrawal.withdrawn;
+
         // Generate secret for this withdrawal
         const nullifier = this._genWithdrawalNullifier(account.label, index);
         const secret = this._genWithdrawalSecret(account.label, index);
+        const precommitment = this._hashPrecommitment(nullifier, secret);
+        const accountCommitment = this._hashCommitment(remainingValue, currentCommitment.label, precommitment)
+        
+        
+        // If the locally-computed hash doesn't match the on-chain commitment,
+        // the withdrawal was performed with different keys (e.g. migration from
+        // legacy to safe keys). Mark the child as unspendable from this account.
+        if (accountCommitment !== withdrawal.newCommitment) {
+          this.logger.info(
+            `Withdrawal commitment hash mismatch — marking as unspendable (migrated with different keys)`,
+            { label: currentCommitment.label, expected: withdrawal.newCommitment, computed: accountCommitment }
+          );
+          
+          // Add the withdrawal commitment to the account
+          const migrationCommitment = this.addMigrationCommitment(
+            currentCommitment,
+            remainingValue,
+            nullifier,
+            secret,
+            withdrawal.blockNumber,
+            withdrawal.transactionHash
+          );    
+
+          currentCommitment = migrationCommitment;
+        } else {
+          // Add the withdrawal commitment to the account
+          const withdrawalCommitment = this.addWithdrawalCommitment(
+            currentCommitment,
+            remainingValue,
+            nullifier,
+            secret,
+            withdrawal.blockNumber,
+            withdrawal.transactionHash
+          );
 
-        // Add the withdrawal commitment to the account
-        const newCommitment = this.addWithdrawalCommitment(
-          currentCommitment,
-          currentCommitment.value - withdrawal.withdrawn,
-          nullifier,
-          secret,
-          withdrawal.blockNumber,
-          withdrawal.transactionHash
-        );
-
-        // Update current commitment to the newly created one
-        currentCommitment = newCommitment;
+          currentCommitment = withdrawalCommitment;
+        }
 
         // Increment index for next potential withdrawal
         index++;
@@ -799,6 +929,88 @@ export class AccountService {
     }
   }
 
+  /**
+   * Discovers commitments that were migrated from legacy accounts via 0-value withdrawal.
+   *
+   * @param scope - The scope of the pool
+   * @param legacyAccounts - The legacy pool accounts for this scope
+   * @param withdrawalEvents - The map of withdrawal events (keyed by spentNullifier)
+   *
+   * @remarks
+   * When a legacy account performs a 0-value withdrawal to rotate keys (migration),
+   * the resulting on-chain commitment is created with safe keys. This method finds
+   * those commitments by:
+   * 1. Identifying legacy accounts with the `isMigrated` flag (set by `addMigrationCommitment`)
+   * 2. Computing the expected commitment hash using safe keys at withdrawal index 0
+   * 3. Verifying the hash exists in on-chain withdrawal events
+   * 4. Adding verified commitments as new safe pool accounts
+   *
+   * @private
+   */
+  private _discoverMigratedCommitments(
+    scope: Hash,
+    legacyAccounts: PoolAccount[],
+    withdrawalEvents: Map<Hash, WithdrawalEvent>
+  ): void {
+    // Build reverse lookup: newCommitment hash → WithdrawalEvent
+    const newCommitmentMap = new Map<Hash, WithdrawalEvent>();
+    for (const event of withdrawalEvents.values()) {
+      newCommitmentMap.set(event.newCommitment, event);
+    }
+
+    for (const legacyAccount of legacyAccounts) {
+      // Skip if not flagged as migrated (set by addMigrationCommitment)
+      if (!legacyAccount.isMigrated) continue;
+
+      const migrationChild = legacyAccount.children.find(c => c.isMigration);
+      if (!migrationChild) continue;
+
+      const label = legacyAccount.label;
+
+      // The migration child's value is the remaining value carried forward.
+      // Zero-value migrations (full withdrawal + key rotation) are valid and
+      // must still be registered so that poolAccounts.length reflects the
+      // correct slot count for deposit index alignment in step C.
+      const remainingValue = migrationChild.value;
+
+      // Generate safe nullifier/secret at withdrawal index 0
+      const nullifier = this._genWithdrawalNullifier(label, 0n);
+      const secret = this._genWithdrawalSecret(label, 0n);
+
+      // Compute expected commitment hash
+      const precommitment = this._hashPrecommitment(nullifier, secret);
+      const expectedHash = this._hashCommitment(remainingValue, label, precommitment);
+
+      // Verify hash exists in withdrawal events' newCommitment
+      const withdrawalEvent = newCommitmentMap.get(expectedHash);
+      if (!withdrawalEvent) continue;
+
+      // Verified — add as a new safe pool account
+      const newAccount = this.addPoolAccount(
+        scope,
+        remainingValue,
+        nullifier,
+        secret,
+        label,
+        withdrawalEvent.blockNumber,
+        withdrawalEvent.transactionHash,
+      );
+
+      this.addWithdrawalCommitment(
+        newAccount.deposit,
+        remainingValue,
+        nullifier,
+        secret,
+        withdrawalEvent.blockNumber,
+        withdrawalEvent.transactionHash,
+      )
+
+      this.logger.info(
+        `Discovered migrated commitment for label ${label} with value ${remainingValue}`,
+      );
+    }
+  }
+
   /**
    * Initializes an AccountService instance with events for a given set of pools
    *
@@ -830,7 +1042,7 @@ export class AccountService {
         service: AccountService;
       },
     pools: PoolInfo[]
-  ): Promise<{ account: AccountService; errors: PoolEventsError[] }> {
+  ): Promise<{ account: AccountService; legacyAccount?: AccountService; errors: PoolEventsError[] }> {
     // Log the start of the history retrieval process
     const logger = new Logger({ prefix: "Account" });
     logger.info(`Fetching events for pools`, { poolLength: pools.length });
@@ -844,32 +1056,114 @@ export class AccountService {
       uniqueScopes.add(pool.scope);
     }
 
+    // Retry path (non-migration): reuse the existing service's account and
+    // only process pools whose scopes haven't been fully processed yet.
+    // Already-processed scopes are skipped to avoid duplicate deposits and
+    // withdrawal misclassification.
+    //
+    // This path performs simple deposit/withdrawal/ragequit processing only
+    // — no migration discovery. For migration-aware retries, the caller
+    // should re-invoke with { mnemonic } scoped to only the failed pools;
+    // the mnemonic path builds both safe and legacy accounts from scratch
+    // with no shared references.
+    if (!('mnemonic' in source)) {
+      const account = new AccountService(
+        dataService,
+        { account: source.service.account }
+      );
+      const processedScopes = source.service.account.poolAccounts;
+      const newPools = pools.filter((p) => !processedScopes.has(p.scope));
+
+      const errors = await account._processEvents(newPools);
+      return { account, errors };
+    }
+
+    // Mnemonic path: phased processing with migration discovery
+    const account = new AccountService(dataService, { mnemonic: source.mnemonic });
+    const legacyPrivacyPoolAccount = AccountService._initializeLegacyAccount(source.mnemonic);
+    const legacyAccount = new AccountService(dataService, { account: legacyPrivacyPoolAccount });
+
+    const errors = await account._processEvents(pools, legacyAccount);
+    return { account, legacyAccount, errors };
+  }
+
+  /**
+   * Fetches and processes events for a set of pools.
+   *
+   * When a legacyAccount is provided, the full migration-aware pipeline runs
+   * for each scope:
+   *   1. Legacy account: process deposits and withdrawals (to detect migrations)
+   *   2. Safe account: discover migrated commitments from the legacy accounts
+   *   3. Safe account (this): process deposits (starting after migrated accounts)
+   *   4. Safe account: process withdrawals (now includes migrated accounts)
+   *   5. Both accounts: process ragequits
+   *
+   * Migration discovery (step 2) must run before safe deposit scanning (step 3)
+   * so that the migrated account count can be used as the starting index.
+   * Post-migration deposits use poolAccounts.length as their index, which
+   * sits right after the migrated slots; scanning from 0 would hit
+   * MAX_CONSECUTIVE_MISSES on the legacy-key indices and never reach them.
+   *
+   * Without a legacyAccount, only steps 3, 4, and 5 run (simple processing).
+   *
+   * Per-scope errors are caught and returned rather than thrown, and any
+   * partial state left by a mid-scope failure is cleaned from both accounts
+   * so that a subsequent retry starts fresh for that scope.
+   */
+  private async _processEvents(
+    pools: PoolInfo[],
+    legacyAccount?: AccountService,
+  ): Promise<PoolEventsError[]> {
     const errors: PoolEventsError[] = [];
-    const account = new AccountService(
-      dataService,
-      "mnemonic" in source
-        ? { mnemonic: source.mnemonic }
-        : { account: source.service.account }
-    );
 
-    const events = await account.getEvents(pools);
+    const events = await this.getEvents(pools);
 
     for (const [scope, result] of events.entries()) {
       if ("reason" in result) {
         errors.push(result);
       } else {
-        // Process deposit events an create pool accounts
-        account._processDepositEvents(scope, result.depositEvents);
+        try {
+          // a. Legacy: process deposits + withdrawals
+          if (legacyAccount) {
+            legacyAccount._processDepositEvents(scope, result.depositEvents);
+            legacyAccount._processWithdrawalEvents(scope, result.withdrawalEvents);
+          }
+
+          // b. Safe: discover migrated commitments from legacy accounts.
+          //    Must run before safe deposit scanning so that the migrated
+          //    account count can serve as the starting index for step (c),
+          //    avoiding a gap of consecutive misses over legacy-key indices.
+          if (legacyAccount) {
+            const legacyAccounts = legacyAccount.account.poolAccounts.get(scope) ?? [];
+            this._discoverMigratedCommitments(scope, legacyAccounts, result.withdrawalEvents);
+          }
+
+          // c. Safe: process deposits, starting after any migrated accounts.
+          //    New deposits created after migration use poolAccounts.length as
+          //    their index, so they sit right after the migrated slots.
+          const depositStartIndex = BigInt(this.account.poolAccounts.get(scope)?.length ?? 0);
+          this._processDepositEvents(scope, result.depositEvents, depositStartIndex);
 
-        // Process withdrawal events and add commitments to pool accounts
-        account._processWithdrawalEvents(scope, result.withdrawalEvents);
+          // d. Safe: process withdrawals (now includes migrated accounts)
+          this._processWithdrawalEvents(scope, result.withdrawalEvents);
 
-        // Process ragequit events and add ragequit to pool accounts
-        account._processRagequitEvents(scope, result.ragequitEvents);
+          // e. Both: process ragequits
+          if (legacyAccount) {
+            legacyAccount._processRagequitEvents(scope, result.ragequitEvents);
+          }
+          this._processRagequitEvents(scope, result.ragequitEvents);
+        } catch (e) {
+          this.account.poolAccounts.delete(scope);
+          legacyAccount?.account.poolAccounts.delete(scope);
+          errors.push({
+            reason: e instanceof Error ? e.message : String(e),
+            scope,
+          });
+        }
       }
     }
 
-    return { account, errors };
+    return errors;
   }
 
   /**

package/src/core/data.service.ts

@@ -158,7 +158,7 @@ export class DataService {
             depositor: depositor.toLowerCase(),
             commitment: commitment as Hash,
             label: label as Hash,
-            value: value || BigInt(0),
+            value: value ?? BigInt(0),
             precommitment: precommitment as Hash,
             blockNumber: BigInt(typedLog.blockNumber),
             transactionHash: typedLog.transactionHash,
@@ -252,13 +252,7 @@ export class DataService {
             _newCommitment: newCommitment,
           } = typedLog.args;
 
-          if (
-            !value ||
-            !spentNullifier ||
-            !newCommitment ||
-            !typedLog.blockNumber ||
-            !typedLog.transactionHash
-          ) {
+          if (value == null || !spentNullifier || !newCommitment || !typedLog.blockNumber || !typedLog.transactionHash) {
             throw DataError.invalidLog("withdrawal", "missing required fields");
           }
 
@@ -374,7 +368,7 @@ export class DataService {
             ragequitter: ragequitter.toLowerCase(),
             commitment: commitment as Hash,
             label: label as Hash,
-            value: value || BigInt(0),
+            value: value ?? BigInt(0),
             blockNumber: BigInt(typedLog.blockNumber),
             transactionHash: typedLog.transactionHash,
           };

package/src/core/tmp.ts

@@ -0,0 +1,4 @@
+"0x4626A182030D9e98b13f690FFF3C443191a918ff",
+"0x2C7bCaf3f966F20506096696bA9Beae216D005a4",
+"0x3706e38af05bf0158BCdbB46239f8289980b093f",
+"0xA63e0bdc3A193d1E6e7c9bE72CB502BE4B7fC244",

package/src/crypto.ts

@@ -1,5 +1,4 @@
 import { mnemonicToAccount } from "viem/accounts";
-import { bytesToNumber } from "viem/utils";
 import { poseidon } from "maci-crypto/build/ts/hashing.js";
 import { LeanIMT, LeanIMTMerkleProof } from "@zk-kit/lean-imt";
 import {
@@ -13,7 +12,7 @@ import {
   Withdrawal,
   MasterKeys,
 } from "./types/index.js";
-import { encodeAbiParameters, Hex, keccak256, numberToHex } from "viem";
+import { bytesToBigInt, encodeAbiParameters, Hex, keccak256, numberToHex } from "viem";
 import { SNARK_SCALAR_FIELD } from "./constants.js";
 
 /**
@@ -45,16 +44,16 @@ export function generateMasterKeys(mnemonic: string): MasterKeys {
         );
     }
      
-    const key1 = bytesToNumber(
+    const key1 = bytesToBigInt(
       mnemonicToAccount(mnemonic, { accountIndex: 0 }).getHdKey().privateKey!,
     );
 
-    const key2 = bytesToNumber(
+    const key2 = bytesToBigInt(
       mnemonicToAccount(mnemonic, { accountIndex: 1 }).getHdKey().privateKey!,
     );
 
-    const masterNullifier = poseidon([BigInt(key1)]) as Secret;
-    const masterSecret = poseidon([BigInt(key2)]) as Secret;
+    const masterNullifier = poseidon([key1]) as Secret;
+    const masterSecret = poseidon([key2]) as Secret;
 
   return { masterNullifier, masterSecret };
 }