@0xbow/privacy-pools-core-sdk 0.1.17 → 0.1.19

package/dist/esm/{fetchArtifacts.esm-pBY20mFG.js → fetchArtifacts.esm-DYA5xgwo.js}

@@ -1,4 +1,4 @@
-import { F as FetchArtifact } from './index-Bce8vsoP.js';
+import { F as FetchArtifact } from './index-IxAruGRY.js';
 import 'viem/accounts';
 import 'buffer';
 import 'assert';
@@ -15,4 +15,4 @@ async function fetchVersionedArtifact(artifactUrl) {
 }
 
 export { fetchVersionedArtifact };
-//# sourceMappingURL=fetchArtifacts.esm-pBY20mFG.js.map
+//# sourceMappingURL=fetchArtifacts.esm-DYA5xgwo.js.map

package/dist/esm/{fetchArtifacts.esm-pBY20mFG.js.map → fetchArtifacts.esm-DYA5xgwo.js.map}

@@ -1 +1 @@
-{"version":3,"file":"fetchArtifacts.esm-pBY20mFG.js","sources":["../../src/circuits/fetchArtifacts.esm.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAEO,eAAe,sBAAsB,CAC1C,WAAgB,EAAA;AAEhB,IAAA,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC;AACpC,IAAA,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE;AACtB,QAAA,MAAM,IAAI,aAAa,CAAC,WAAW,CAAC;;AAEtC,IAAA,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,WAAW,EAAE;AACpC,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC;AAC7B;;;;"}
+{"version":3,"file":"fetchArtifacts.esm-DYA5xgwo.js","sources":["../../src/circuits/fetchArtifacts.esm.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAEO,eAAe,sBAAsB,CAC1C,WAAgB,EAAA;AAEhB,IAAA,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,WAAW,CAAC;AACpC,IAAA,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE;AACtB,QAAA,MAAM,IAAI,aAAa,CAAC,WAAW,CAAC;;AAEtC,IAAA,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,WAAW,EAAE;AACpC,IAAA,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC;AAC7B;;;;"}

package/dist/esm/{fetchArtifacts.node-B2yyjJ3A.js → fetchArtifacts.node-nt928XQR.js}

@@ -1,4 +1,4 @@
-import { F as FetchArtifact } from './index-Bce8vsoP.js';
+import { F as FetchArtifact } from './index-IxAruGRY.js';
 import 'viem/accounts';
 import 'buffer';
 import 'assert';
@@ -28,4 +28,4 @@ async function fetchVersionedArtifact(artifactUrl) {
 }
 
 export { fetchVersionedArtifact };
-//# sourceMappingURL=fetchArtifacts.node-B2yyjJ3A.js.map
+//# sourceMappingURL=fetchArtifacts.node-nt928XQR.js.map

package/dist/esm/{fetchArtifacts.node-B2yyjJ3A.js.map → fetchArtifacts.node-nt928XQR.js.map}

@@ -1 +1 @@
-{"version":3,"file":"fetchArtifacts.node-B2yyjJ3A.js","sources":["../../src/circuits/fetchArtifacts.node.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAEO,eAAe,sBAAsB,CAC1C,WAAgB,EAAA;AAEhB,IAAA,IAAI;QACF,MAAM,EAAE,GAAG,CAAC,MAAM,OAAO,IAAI,CAAC,EAAE,OAAO;QACvC,MAAM,WAAW,GAAoB,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAI;AACnE,YAAA,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAI;gBAC9C,IAAI,GAAG,EAAE;oBACP,MAAM,CAAC,GAAG,CAAC;;qBACN;oBACL,OAAO,CAAC,IAAI,CAAC;;AAEjB,aAAC,CAAC;AACJ,SAAC,CAAC;AACF,QAAA,MAAM,GAAG,GAAG,MAAM,WAAW;AAC7B,QAAA,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC;;IAC1B,OAAO,KAAK,EAAE;AACd,QAAA,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;AACpB,QAAA,MAAM,IAAI,aAAa,CAAC,WAAW,CAAC;;AAExC;;;;"}
+{"version":3,"file":"fetchArtifacts.node-nt928XQR.js","sources":["../../src/circuits/fetchArtifacts.node.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;AAEO,eAAe,sBAAsB,CAC1C,WAAgB,EAAA;AAEhB,IAAA,IAAI;QACF,MAAM,EAAE,GAAG,CAAC,MAAM,OAAO,IAAI,CAAC,EAAE,OAAO;QACvC,MAAM,WAAW,GAAoB,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,KAAI;AACnE,YAAA,EAAE,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,IAAI,KAAI;gBAC9C,IAAI,GAAG,EAAE;oBACP,MAAM,CAAC,GAAG,CAAC;;qBACN;oBACL,OAAO,CAAC,IAAI,CAAC;;AAEjB,aAAC,CAAC;AACJ,SAAC,CAAC;AACF,QAAA,MAAM,GAAG,GAAG,MAAM,WAAW;AAC7B,QAAA,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC;;IAC1B,OAAO,KAAK,EAAE;AACd,QAAA,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;AACpB,QAAA,MAAM,IAAI,aAAa,CAAC,WAAW,CAAC;;AAExC;;;;"}

package/dist/esm/{index-Bce8vsoP.js → index-IxAruGRY.js}

@@ -45815,10 +45815,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-pBY20mFG.js');
+        return import('./fetchArtifacts.esm-DYA5xgwo.js');
     }
     else {
-        return import('./fetchArtifacts.node-B2yyjJ3A.js');
+        return import('./fetchArtifacts.node-nt928XQR.js');
     }
 }
 
@@ -46098,9 +46098,9 @@ const IEntrypointABI = [
                 "internalType": "uint256"
             },
             {
-                "name": "ipfsHash",
-                "type": "bytes32",
-                "internalType": "bytes32"
+                "name": "ipfsCID",
+                "type": "string",
+                "internalType": "string"
             },
             {
                 "name": "timestamp",
@@ -46497,9 +46497,9 @@ const IEntrypointABI = [
                 "internalType": "uint256"
             },
             {
-                "name": "_ipfsHash",
-                "type": "bytes32",
-                "internalType": "bytes32"
+                "name": "_ipfsCID",
+                "type": "string",
+                "internalType": "string"
             }
         ],
         "outputs": [
@@ -46815,10 +46815,10 @@ const IEntrypointABI = [
                 "internalType": "uint256"
             },
             {
-                "name": "_ipfsHash",
-                "type": "bytes32",
+                "name": "_ipfsCID",
+                "type": "string",
                 "indexed": false,
-                "internalType": "bytes32"
+                "internalType": "string"
             },
             {
                 "name": "_timestamp",
@@ -46937,11 +46937,6 @@ const IEntrypointABI = [
         "name": "ERC1967NonPayable",
         "inputs": []
     },
-    {
-        "type": "error",
-        "name": "EmptyIPFSHash",
-        "inputs": []
-    },
     {
         "type": "error",
         "name": "EmptyRoot",
@@ -46962,6 +46957,11 @@ const IEntrypointABI = [
         "name": "InvalidFeeBPS",
         "inputs": []
     },
+    {
+        "type": "error",
+        "name": "InvalidIPFSCIDLength",
+        "inputs": []
+    },
     {
         "type": "error",
         "name": "InvalidIndex",
@@ -47068,7 +47068,7 @@ const IEntrypointABI = [
         "type": "error",
         "name": "ZeroAddress",
         "inputs": []
-    },
+    }
 ];
 
 const IPrivacyPoolABI = [
@@ -69145,6 +69145,22 @@ class WithdrawalService {
      * Prepares input signals for the withdrawal circuit.
      */
     prepareInputSignals(commitment, input) {
+        let existingValue;
+        let existingNullifier;
+        let existingSecret;
+        let label;
+        if ("preimage" in commitment) {
+            existingValue = commitment.preimage.value;
+            existingNullifier = commitment.preimage.precommitment.nullifier;
+            existingSecret = commitment.preimage.precommitment.secret;
+            label = commitment.preimage.label;
+        }
+        else {
+            existingValue = commitment.value;
+            existingNullifier = commitment.nullifier;
+            existingSecret = commitment.secret;
+            label = commitment.label;
+        }
         return {
             // Public signals
             withdrawnValue: input.withdrawalAmount,
@@ -69154,10 +69170,10 @@ class WithdrawalService {
             ASPTreeDepth: input.aspTreeDepth,
             context: input.context,
             // Private signals
-            label: commitment.preimage.label,
-            existingValue: commitment.preimage.value,
-            existingNullifier: commitment.preimage.precommitment.nullifier,
-            existingSecret: commitment.preimage.precommitment.secret,
+            label,
+            existingValue,
+            existingNullifier,
+            existingSecret,
             newNullifier: input.newNullifier,
             newSecret: input.newSecret,
             // Merkle Proofs
@@ -69237,6 +69253,12 @@ class AccountError extends SDKError {
     static accountInitializationFailed(reason) {
         return new AccountError(`Failed to initialize account: ${reason}`, ErrorCode.OPERATION_FAILED);
     }
+    static duplicatePools(scope) {
+        return new AccountError(`Duplicate pools found for scope: ${scope.toString()}`, ErrorCode.INVALID_INPUT);
+    }
+    static invalidIndex(index) {
+        return new AccountError(`Invalid index: ${index.toString()}`, ErrorCode.INVALID_INPUT);
+    }
 }
 
 var LogLevel;
@@ -69280,6 +69302,38 @@ class Logger {
     }
 }
 
+class DataError extends SDKError {
+    constructor(message, code = ErrorCode.NETWORK_ERROR, details) {
+        super(message, code, details);
+        this.name = "DataError";
+    }
+    static invalidLog(type, reason) {
+        return new DataError(`Invalid ${type} log: ${reason}`, ErrorCode.INVALID_INPUT);
+    }
+    static chainNotConfigured(chainId) {
+        return new DataError(`No configuration found for chain ID ${chainId}`, ErrorCode.INVALID_INPUT);
+    }
+    static networkError(chainId, error) {
+        return new DataError(`Network error on chain ${chainId}: ${error.message}`, ErrorCode.NETWORK_ERROR, { originalError: error });
+    }
+}
+
+class EventError extends DataError {
+    constructor(message, code = ErrorCode.NETWORK_ERROR, details) {
+        super(message, code, details);
+        this.name = "EventError";
+    }
+    static depositEventError(chainId, scope, error) {
+        return new EventError(`Error fetching deposit events for chain ${chainId}: ${error.message}`, ErrorCode.NETWORK_ERROR, { originalError: error, scope });
+    }
+    static withdrawalEventError(chainId, scope, error) {
+        return new EventError(`Error fetching withdrawal events for chain ${chainId}: ${error.message}`, ErrorCode.NETWORK_ERROR, { originalError: error, scope });
+    }
+    static ragequitEventError(chainId, scope, error) {
+        return new EventError(`Error fetching ragequit events for chain ${chainId}: ${error.message}`, ErrorCode.NETWORK_ERROR, { originalError: error, scope });
+    }
+}
+
 /**
  * Service responsible for managing privacy pool accounts and their associated commitments.
  * Handles account initialization, deposit/withdrawal tracking, and history synchronization.
@@ -69296,15 +69350,21 @@ class AccountService {
      * Creates a new AccountService instance.
      *
      * @param dataService - Service for fetching on-chain events
-     * @param account - Optional existing account to initialize with
-     * @param mnemonic - Optional mnemonic for deterministic key generation
+     * @param config - Configuration for the account service (either mnemonic or existing account)
+     * @param config.mnemonic - Optional mnemonic for deterministic key generation
+     * @param config.account - Optional existing account to initialize with
      *
      * @throws {AccountError} If account initialization fails
      */
-    constructor(dataService, mnemonic, account) {
+    constructor(dataService, config) {
         this.dataService = dataService;
         this.logger = new Logger({ prefix: "Account" });
-        this.account = account || this._initializeAccount(mnemonic);
+        if ("mnemonic" in config) {
+            this.account = this._initializeAccount(config.mnemonic);
+        }
+        else {
+            this.account = config.account;
+        }
     }
     /**
      * Initializes a new account from a mnemonic phrase.
@@ -69332,7 +69392,7 @@ class AccountService {
                 masterKeys: [masterNullifier, masterSecret],
                 poolAccounts: new Map(),
                 creationTimestamp: 0n,
-                lastUpdateTimestamp: 0n
+                lastUpdateTimestamp: 0n,
             };
         }
         catch (error) {
@@ -69454,8 +69514,11 @@ class AccountService {
      * The precommitment is a hash of the nullifier and secret, used in the deposit process.
      */
     createDepositSecrets(scope, index) {
+        if (index && index < 0n) {
+            throw AccountError.invalidIndex(index);
+        }
         const accounts = this.account.poolAccounts.get(scope);
-        index = index || BigInt(accounts?.length || 0);
+        index = index ?? BigInt(accounts?.length || 0);
         const nullifier = this._genDepositNullifier(scope, index);
         const secret = this._genDepositSecret(scope, index);
         const precommitment = this._hashPrecommitment(nullifier, secret);
@@ -69613,6 +69676,272 @@ class AccountService {
         return foundAccount;
     }
     /**
+     * Fetches deposit events for a given pool and returns a map of precommitments to their events for efficient lookup
+     *
+     * @param pool - The pool to fetch deposit events for
+     *
+     * @returns A map of precommitments to their events
+     */
+    async getDepositEvents(pool) {
+        try {
+            const depositEvents = await this.dataService.getDeposits(pool);
+            this.logger.info(`Found deposits for pool`, {
+                poolAddress: pool.address,
+                poolChainId: pool.chainId,
+                depositCount: depositEvents.length,
+            });
+            const depositMap = new Map();
+            for (const event of depositEvents) {
+                depositMap.set(event.precommitment, event);
+            }
+            return depositMap;
+        }
+        catch (error) {
+            throw EventError.depositEventError(pool.chainId, pool.scope, error);
+        }
+    }
+    /**
+     * Fetches withdrawal events for a given pool and returns a map of spent nullifiers to their events for efficient lookup
+     *
+     * @param pool - The pool to fetch withdrawal events for
+     *
+     * @returns A map of spent nullifiers to their events
+     */
+    async getWithdrawalEvents(pool) {
+        try {
+            const withdrawalEvents = await this.dataService.getWithdrawals(pool);
+            const withdrawalMap = new Map();
+            for (const event of withdrawalEvents) {
+                withdrawalMap.set(event.spentNullifier, event);
+            }
+            return withdrawalMap;
+        }
+        catch (error) {
+            throw EventError.withdrawalEventError(pool.chainId, pool.scope, error);
+        }
+    }
+    /**
+     * Fetches ragequit events for a given pool and returns a map of ragequit labels to their events for efficient lookup
+     *
+     * @param pool - The pool to fetch ragequit events for
+     *
+     * @returns A map of ragequit labels to their events
+     */
+    async getRagequitEvents(pool) {
+        try {
+            const ragequitEvents = await this.dataService.getRagequits(pool);
+            const ragequitMap = new Map();
+            for (const event of ragequitEvents) {
+                ragequitMap.set(event.label, event);
+            }
+            return ragequitMap;
+        }
+        catch (error) {
+            throw EventError.ragequitEventError(pool.chainId, pool.scope, error);
+        }
+    }
+    /**
+     * Fetches events for a given set of pools
+     *
+     * @param pools - The pools to fetch events for
+     *
+     * @returns A map of pool scopes to their events
+     */
+    async getEvents(pools) {
+        const events = new Map();
+        const poolEventResults = await Promise.allSettled(pools.map(async (pool) => {
+            this.logger.info(`Fetching events for pool`, {
+                poolAddress: pool.address,
+                poolChainId: pool.chainId,
+                poolDeploymentBlock: pool.deploymentBlock,
+            });
+            const [depositEvents, withdrawalEvents, ragequitEvents] = await Promise.all([
+                this.getDepositEvents(pool),
+                this.getWithdrawalEvents(pool),
+                this.getRagequitEvents(pool),
+            ]);
+            return {
+                scope: pool.scope,
+                depositEvents,
+                withdrawalEvents,
+                ragequitEvents,
+            };
+        }));
+        for (const result of poolEventResults) {
+            if (result.status === "fulfilled") {
+                const { scope, depositEvents, withdrawalEvents, ragequitEvents } = result.value;
+                events.set(scope, {
+                    depositEvents,
+                    withdrawalEvents,
+                    ragequitEvents,
+                });
+            }
+            else {
+                events.set(result.reason.details?.scope, {
+                    reason: result.reason.message,
+                    scope: result.reason.details?.scope,
+                });
+            }
+        }
+        return events;
+    }
+    /**
+     * Processes deposit events for a given scope and adds them to the account
+     * Deterministically generate deposit secrets and check if they match on-chain deposits
+     *
+     * @param scope - The scope of the pool
+     * @param depositEvents - The map of deposit events
+     *
+     */
+    _processDepositEvents(scope, depositEvents) {
+        for (let index = BigInt(0); index < depositEvents.size; index++) {
+            // Generate nullifier, secret, and precommitment for this index
+            const { nullifier, secret, precommitment } = this.createDepositSecrets(scope, index);
+            // Look for a deposit with this precommitment
+            const event = depositEvents.get(precommitment);
+            if (!event) {
+                break; // No more deposits found, exit the loop
+            }
+            // Create a new pool account for this deposit
+            this.addPoolAccount(scope, event.value, nullifier, secret, event.label, event.blockNumber, event.transactionHash);
+        }
+    }
+    /**
+     * Processes withdrawal events for a given scope and adds them to the account
+     *
+     * @param scope - The scope of the pool
+     * @param withdrawalEvents - The map of withdrawal events
+     *
+     * @remarks
+     * This method performs the following steps for each pool:
+     * 1. Identifies the earliest deposit block for each scope
+     * 2. For each account, reconstructs the withdrawal history by:
+     *    - Generating nullifiers sequentially
+     *    - Matching them against on-chain events
+     *    - Adding matched withdrawals to the account state
+     *
+     * @throws {DataError} If event fetching fails
+     * @private
+     *
+     */
+    _processWithdrawalEvents(scope, withdrawalEvents) {
+        const accounts = this.account.poolAccounts.get(scope);
+        // Skip if no accounts for this scope
+        if (!accounts || accounts.length === 0) {
+            this.logger.info(`No accounts found for pool with this scope`, {
+                scope,
+            });
+            return;
+        }
+        // Process each account in parallel for better performance
+        for (const account of accounts) {
+            let currentCommitment = account.deposit;
+            let index = BigInt(0);
+            // Continue processing withdrawals until no more are found secuentially
+            while (true) {
+                // Generate nullifier for this withdrawal
+                const nullifierHash = hashingExports.poseidon([currentCommitment.nullifier]);
+                // Look for a withdrawal event with this nullifier
+                const withdrawal = withdrawalEvents.get(nullifierHash);
+                if (!withdrawal) {
+                    break;
+                }
+                // Generate secret for this withdrawal
+                const nullifier = this._genWithdrawalNullifier(account.label, index);
+                const secret = this._genWithdrawalSecret(account.label, index);
+                // 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;
+                // Increment index for next potential withdrawal
+                index++;
+            }
+        }
+    }
+    /**
+     * Processes ragequit events for a given scope and adds them to the account
+     *
+     * @param scope - The scope of the pool
+     * @param ragequitEvents - The map of ragequit events
+     *
+     * @remarks
+     * This method performs the following steps for each pool:
+     * 1. Adds ragequit events to accounts if found
+     *
+     * @throws {DataError} If event fetching fails
+     * @private
+     *
+     */
+    _processRagequitEvents(scope, ragequitEvents) {
+        const accounts = this.account.poolAccounts.get(scope);
+        if (!accounts || accounts.length === 0) {
+            this.logger.info(`No accounts found for pool with this scope`, {
+                scope,
+            });
+            return;
+        }
+        for (const account of accounts) {
+            const ragequit = ragequitEvents.get(account.label);
+            if (ragequit) {
+                this.addRagequitToAccount(account.label, ragequit);
+            }
+        }
+    }
+    /**
+     * Initializes an AccountService instance with events for a given set of pools
+     *
+     * @param dataService - The data service to use for fetching events
+     * @param source - The source to use for initializing the account. Either a mnemonic or an existing account service instance
+     * @param pools - The pools to fetch events for
+     *
+     * @remarks
+     * This method performs the following steps for each pool:
+     * 1. Fetches deposit, withdrawal, and ragequit events for each pool
+     * 2. Processes deposit events and creates pool accounts
+     * 3. Processes withdrawal events and adds commitments to pool accounts
+     * 4. Processes ragequit events and adds ragequit to pool accounts
+     *
+     * @returns The initialized AccountService instance and array of errors if any pool events fetching fails
+     *
+     * if any pool events fetching fails, the account will be initialized without the events for that pool
+     * user can then call to this method again with the same account and missing pools to fetch the missing events
+     *
+     * @throws {AccountError} If account state reconstruction fails or if duplicate pools are found
+     */
+    static async initializeWithEvents(dataService, source, pools) {
+        // Log the start of the history retrieval process
+        const logger = new Logger({ prefix: "Account" });
+        logger.info(`Fetching events for pools`, { poolLength: pools.length });
+        // verify that pools don't contain duplicates based on scope
+        const uniqueScopes = new Set();
+        for (const pool of pools) {
+            if (uniqueScopes.has(pool.scope)) {
+                throw AccountError.duplicatePools(pool.scope);
+            }
+            uniqueScopes.add(pool.scope);
+        }
+        const errors = [];
+        const account = new AccountService(dataService, "mnemonic" in source
+            ? { mnemonic: source.mnemonic }
+            : { account: source.service.account });
+        const events = await account.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);
+                // Process withdrawal events and add commitments to pool accounts
+                account._processWithdrawalEvents(scope, result.withdrawalEvents);
+                // Process ragequit events and add ragequit to pool accounts
+                account._processRagequitEvents(scope, result.ragequitEvents);
+            }
+        }
+        return { account, errors };
+    }
+    /**
+     * @deprecated Use `initializeWithEvents` for instantiating an account with history reconstruction
      * Retrieves the history of deposits and withdrawals for the given pools.
      *
      * @param pools - Array of pool configurations to sync history for
@@ -69682,10 +70011,10 @@ class AccountService {
                 return;
             }
             this.logger.info(`Found ${foundDeposits.length} deposits for pool ${pool.address}`);
-            // Process withdrawals and ragequits for all pools
-            // This is done after all deposits are processed to ensure we have the complete account state
-            await this._processWithdrawalsAndRagequits(pools);
         }));
+        // Process withdrawals and ragequits for all pools
+        // This is done after all deposits are processed to ensure we have the complete account state
+        await this._processWithdrawalsAndRagequits(pools);
     }
     /**
      * Processes withdrawal events for all pools and updates account state.
@@ -69745,7 +70074,9 @@ class AccountService {
                 // Continue processing withdrawals until no more are found
                 while (true) {
                     // Generate nullifier for this withdrawal
-                    const nullifierHash = hashingExports.poseidon([currentCommitment.nullifier]);
+                    const nullifierHash = hashingExports.poseidon([
+                        currentCommitment.nullifier,
+                    ]);
                     // Look for a withdrawal event with this nullifier
                     const withdrawal = withdrawalMap.get(nullifierHash);
                     if (!withdrawal) {
@@ -69770,22 +70101,6 @@ class AccountService {
     }
 }
 
-class DataError extends SDKError {
-    constructor(message, code = ErrorCode.NETWORK_ERROR, details) {
-        super(message, code, details);
-        this.name = "DataError";
-    }
-    static invalidLog(type, reason) {
-        return new DataError(`Invalid ${type} log: ${reason}`, ErrorCode.INVALID_INPUT);
-    }
-    static chainNotConfigured(chainId) {
-        return new DataError(`No configuration found for chain ID ${chainId}`, ErrorCode.INVALID_INPUT);
-    }
-    static networkError(chainId, error) {
-        return new DataError(`Network error on chain ${chainId}: ${error.message}`, ErrorCode.NETWORK_ERROR, { originalError: error });
-    }
-}
-
 // Event signatures from the contract
 const DEPOSIT_EVENT = parseAbiItem('event Deposited(address indexed _depositor, uint256 _commitment, uint256 _label, uint256 _value, uint256 _merkleRoot)');
 const WITHDRAWAL_EVENT = parseAbiItem('event Withdrawn(address indexed _processooor, uint256 _value, uint256 _spentNullifier, uint256 _newCommitment)');
@@ -69814,12 +70129,11 @@ class DataService {
         this.logger = new Logger({ prefix: "Data" });
         try {
             for (const config of chainConfigs) {
-                if (!config.rpcUrl || !config.apiKey) {
-                    throw new Error(`Missing RPC URL or API key for chain ${config.chainId}`);
+                if (!config.rpcUrl) {
+                    throw new Error(`Missing RPC URL for chain ${config.chainId}`);
                 }
                 const client = createPublicClient({
                     transport: http(config.rpcUrl),
-                    key: config.apiKey,
                 });
                 this.clients.set(config.chainId, client);
             }
@@ -69995,4 +70309,4 @@ class DataService {
 }
 
 export { AccountService as A, BlockchainProvider as B, CommitmentService as C, DataService as D, ErrorCode as E, FetchArtifact as F, InvalidRpcUrl as I, PrivacyPoolSDK as P, SDKError as S, WithdrawalService as W, generateDepositSecrets as a, generateWithdrawalSecrets as b, getCommitment as c, generateMerkleProof as d, bigintToHash as e, bigintToHex as f, generateMasterKeys as g, hashPrecommitment as h, calculateContext as i, Circuits as j, ContractInteractionsService as k, ProofError as l, ContractError as m, AccountError as n, CircuitName as o };
-//# sourceMappingURL=index-Bce8vsoP.js.map
+//# sourceMappingURL=index-IxAruGRY.js.map