@0xbow/privacy-pools-core-sdk 0.1.14 → 0.1.15

package/dist/esm/{fetchArtifacts.esm-CN7uN1ly.js → fetchArtifacts.esm-tTGl04fU.js}

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

package/dist/esm/{fetchArtifacts.esm-CN7uN1ly.js.map → fetchArtifacts.esm-tTGl04fU.js.map}

@@ -1 +1 @@
-{"version":3,"file":"fetchArtifacts.esm-CN7uN1ly.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-tTGl04fU.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-B93BS926.js → fetchArtifacts.node-xJWJ5ErU.js}

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

package/dist/esm/{fetchArtifacts.node-B93BS926.js.map → fetchArtifacts.node-xJWJ5ErU.js.map}

@@ -1 +1 @@
-{"version":3,"file":"fetchArtifacts.node-B93BS926.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-xJWJ5ErU.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-B2wT3cOz.js → index-CGSW-te1.js}

@@ -45815,10 +45815,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-CN7uN1ly.js');
+        return import('./fetchArtifacts.esm-tTGl04fU.js');
     }
     else {
-        return import('./fetchArtifacts.node-B93BS926.js');
+        return import('./fetchArtifacts.node-xJWJ5ErU.js');
     }
 }
 
@@ -68684,6 +68684,21 @@ class AccountService {
         this.logger = new Logger({ prefix: "Account" });
         this.account = account || this._initializeAccount(mnemonic);
     }
+    /**
+     * 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
+     */
     _initializeAccount(mnemonic) {
         try {
             this.logger.debug("Initializing account with mnemonic");
@@ -68702,25 +68717,74 @@ class AccountService {
             throw AccountError.accountInitializationFailed(error instanceof Error ? error.message : "Unknown error");
         }
     }
+    /**
+     * Generates a deterministic nullifier for a deposit.
+     *
+     * @param scope - The scope of the pool
+     * @param index - The index of the deposit
+     * @returns A deterministic nullifier for the deposit
+     * @private
+     */
     _genDepositNullifier(scope, index) {
         const [masterNullifier] = this.account.masterKeys;
         return hashingExports.poseidon([masterNullifier, scope, index]);
     }
+    /**
+     * Generates a deterministic secret for a deposit.
+     *
+     * @param scope - The scope of the pool
+     * @param index - The index of the deposit
+     * @returns A deterministic secret for the deposit
+     * @private
+     */
     _genDepositSecret(scope, index) {
         const [, masterSecret] = this.account.masterKeys;
         return hashingExports.poseidon([masterSecret, scope, index]);
     }
+    /**
+     * Generates a deterministic nullifier for a withdrawal.
+     *
+     * @param label - The label of the commitment
+     * @param index - The index of the withdrawal
+     * @returns A deterministic nullifier for the withdrawal
+     * @private
+     */
     _genWithdrawalNullifier(label, index) {
         const [masterNullifier] = this.account.masterKeys;
         return hashingExports.poseidon([masterNullifier, label, index]);
     }
+    /**
+     * Generates a deterministic secret for a withdrawal.
+     *
+     * @param label - The label of the commitment
+     * @param index - The index of the withdrawal
+     * @returns A deterministic secret for the withdrawal
+     * @private
+     */
     _genWithdrawalSecret(label, index) {
         const [, masterSecret] = this.account.masterKeys;
         return hashingExports.poseidon([masterSecret, label, index]);
     }
+    /**
+     * Hashes a commitment using the Poseidon hash function.
+     *
+     * @param value - The value of the commitment
+     * @param label - The label of the commitment
+     * @param precommitment - The precommitment hash
+     * @returns The commitment hash
+     * @private
+     */
     _hashCommitment(value, label, precommitment) {
         return hashingExports.poseidon([value, label, precommitment]);
     }
+    /**
+     * Hashes a precommitment using the Poseidon hash function.
+     *
+     * @param nullifier - The nullifier for the commitment
+     * @param secret - The secret for the commitment
+     * @returns The precommitment hash
+     * @private
+     */
     _hashPrecommitment(nullifier, secret) {
         return hashingExports.poseidon([nullifier, secret]);
     }
@@ -68728,12 +68792,21 @@ class AccountService {
      * Gets all spendable commitments across all pools.
      *
      * @returns A map of scope to array of spendable commitments
+     *
+     * @remarks
+     * A commitment is considered spendable if:
+     * 1. It has a non-zero value
+     * 2. The account it belongs to has not been ragequit
      */
     getSpendableCommitments() {
         const result = new Map();
         for (const [scope, accounts] of this.account.poolAccounts.entries()) {
             const nonZeroCommitments = [];
             for (const account of accounts) {
+                // Skip accounts that have been ragequit
+                if (account.ragequit) {
+                    continue;
+                }
                 const lastCommitment = account.children.length > 0
                     ? account.children[account.children.length - 1]
                     : account.deposit;
@@ -68753,6 +68826,10 @@ class AccountService {
      * @param scope - The scope of the pool to deposit into
      * @param index - Optional index for deterministic generation
      * @returns The nullifier, secret, and precommitment for the deposit
+     *
+     * @remarks
+     * If no index is provided, it uses the current number of accounts for the scope.
+     * The precommitment is a hash of the nullifier and secret, used in the deposit process.
      */
     createDepositSecrets(scope, index) {
         const accounts = this.account.poolAccounts.get(scope);
@@ -68767,6 +68844,12 @@ class AccountService {
      *
      * @param commitment - The commitment to spend
      * @returns The nullifier and secret for the new commitment
+     *
+     * @remarks
+     * The index used for generating the withdrawal nullifier and secret is based on
+     * the number of children the account already has, ensuring each withdrawal has
+     * a unique nullifier.
+     *
      * @throws {AccountError} If no account is found for the commitment
      */
     createWithdrawalSecrets(commitment) {
@@ -68796,6 +68879,11 @@ class AccountService {
      * @param blockNumber - The block number of the deposit
      * @param txHash - The transaction hash of the deposit
      * @returns The new pool account
+     *
+     * @remarks
+     * This method creates a new account with the deposit commitment and adds it to the
+     * pool accounts map under the specified scope. The commitment hash is calculated
+     * from the value, label, and precommitment.
      */
     addPoolAccount(scope, value, nullifier, secret, label, blockNumber, txHash) {
         const precommitment = this._hashPrecommitment(nullifier, secret);
@@ -68830,6 +68918,12 @@ class AccountService {
      * @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
      */
     addWithdrawalCommitment(parentCommitment, value, nullifier, secret, blockNumber, txHash) {
@@ -68863,6 +68957,39 @@ class AccountService {
         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
+     *
+     * @param label - The label of the account to add the ragequit to
+     * @param ragequit - The ragequit event to add
+     * @returns The updated pool account
+     *
+     * @remarks
+     * When an account has a ragequit event, it can no longer be spent.
+     * This method finds the account with the matching label and attaches
+     * the ragequit event to it.
+     *
+     * @throws {AccountError} If no account is found with the given label
+     */
+    addRagequitToAccount(label, ragequit) {
+        let foundAccount;
+        let foundScope;
+        // Find the account with the matching label
+        for (const [scope, accounts] of this.account.poolAccounts.entries()) {
+            foundAccount = accounts.find((account) => account.label === label);
+            if (foundAccount) {
+                foundScope = scope;
+                break;
+            }
+        }
+        if (!foundAccount || !foundScope) {
+            throw new AccountError(`No account found with label ${label}`, ErrorCode.INVALID_INPUT);
+        }
+        // Add the ragequit event to the account
+        foundAccount.ragequit = ragequit;
+        this.logger.info(`Added ragequit event to account with label ${label}, value ${ragequit.value}`);
+        return foundAccount;
+    }
     /**
      * Retrieves the history of deposits and withdrawals for the given pools.
      *
@@ -68870,85 +68997,154 @@ class AccountService {
      *
      * @remarks
      * This method performs the following steps:
-     * 1. Fetches all deposit events for each pool
-     * 2. Reconstructs account state from deposits
-     * 3. Processes withdrawals to update account state
+     * 1. Initializes pool accounts for each pool if they don't exist
+     * 2. For each pool, fetches deposit events and reconstructs accounts
+     * 3. Processes withdrawals and ragequits to update account state
+     *
+     * The account reconstruction is deterministic based on the master keys,
+     * allowing the full state to be recovered from on-chain events.
      *
      * @throws {DataError} If event fetching fails
      * @throws {AccountError} If account state reconstruction fails
      */
     async retrieveHistory(pools) {
+        // Log the start of the history retrieval process
         this.logger.info(`Fetching events for ${pools.length} pools`);
+        // Initialize pool accounts map for each pool if it doesn't exist
         for (const pool of pools) {
             if (!this.account.poolAccounts.has(pool.scope)) {
                 this.account.poolAccounts.set(pool.scope, []);
             }
         }
+        // Process all pools in parallel for better performance
         await Promise.all(pools.map(async (pool) => {
+            // Log which pool is being processed
             this.logger.info(`Processing pool ${pool.address} on chain ${pool.chainId} from block ${pool.deploymentBlock}`);
-            const deposits = await this.dataService.getDeposits(pool.chainId, {
-                fromBlock: pool.deploymentBlock,
-            });
+            // Fetch all deposit events for this pool
+            const deposits = await this.dataService.getDeposits(pool);
             this.logger.info(`Found ${deposits.length} deposits for pool ${pool.address}`);
+            // Create a map of deposits by precommitment for efficient lookup
             const depositMap = new Map();
             for (const deposit of deposits) {
                 depositMap.set(deposit.precommitment, deposit);
             }
+            // Track found deposits for logging and debugging
             const foundDeposits = [];
+            // Start with index 0 and try to find deposits deterministically
             let index = BigInt(0);
             let firstDepositBlock;
+            // Deterministically generate deposit secrets and check if they match on-chain deposits
             while (true) {
+                // Generate nullifier, secret, and precommitment for this index
                 const nullifier = this._genDepositNullifier(pool.scope, index);
                 const secret = this._genDepositSecret(pool.scope, index);
                 const precommitment = this._hashPrecommitment(nullifier, secret);
+                // Look for a deposit with this precommitment
                 const deposit = depositMap.get(precommitment);
                 if (!deposit)
-                    break;
+                    break; // No more deposits found, exit the loop
+                // Track the earliest deposit block for later withdrawal processing
                 if (!firstDepositBlock || deposit.blockNumber < firstDepositBlock) {
                     firstDepositBlock = deposit.blockNumber;
                 }
-                foundDeposits.push({ index, nullifier, secret, deposit });
+                // Create a new pool account for this deposit
+                this.addPoolAccount(pool.scope, deposit.value, nullifier, secret, deposit.label, deposit.blockNumber, deposit.transactionHash);
+                // Track the found deposit
+                foundDeposits.push({ index, nullifier, secret, pool, deposit });
+                // Move to the next index
                 index++;
             }
-            if (foundDeposits.length === 0) {
+            // If no accounts were found for this scope, log and skip further processing
+            if (this.account.poolAccounts.get(pool.scope).length === 0) {
                 this.logger.info(`No Pool Accounts were found for scope ${pool.scope}`);
                 return;
             }
             this.logger.info(`Found ${foundDeposits.length} deposits for pool ${pool.address}`);
-            // Process deposits first
-            const accounts = foundDeposits.map(({ nullifier, secret, deposit }) => {
-                return this.addPoolAccount(pool.scope, deposit.value, nullifier, secret, deposit.label, deposit.blockNumber, deposit.transactionHash);
-            });
-            // Create a map for faster account lookups
-            const accountMap = new Map();
-            for (const account of accounts) {
-                accountMap.set(account.label, account);
-            }
-            // Process withdrawals
-            await this._processWithdrawals(pool.chainId, firstDepositBlock, accountMap);
+            // 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);
         }));
     }
-    async _processWithdrawals(chainId, fromBlock, foundAccounts) {
-        const withdrawals = await this.dataService.getWithdrawals(chainId, {
-            fromBlock,
-        });
-        for (const withdrawal of withdrawals) {
-            for (const account of foundAccounts.values()) {
-                const isParentCommitment = BigInt(account.deposit.nullifier) === BigInt(withdrawal.spentNullifier) ||
-                    account.children.some(child => BigInt(child.nullifier) === BigInt(withdrawal.spentNullifier));
-                if (isParentCommitment) {
-                    const parentCommitment = account.children.length > 0
-                        ? account.children[account.children.length - 1]
-                        : account.deposit;
-                    if (!parentCommitment) {
-                        this.logger.warn(`No parent commitment found for withdrawal ${withdrawal.spentNullifier.toString()}`);
-                        continue;
+    /**
+     * Processes withdrawal events for all pools and updates account state.
+     *
+     * @param pools - Array of pool configurations to process withdrawals for
+     *
+     * @remarks
+     * This method performs the following steps for each pool:
+     * 1. Identifies the earliest deposit block for each scope
+     * 2. Fetches withdrawal and ragequit events from that block
+     * 3. Maps withdrawals by nullifier hash and ragequits by label for efficient lookup
+     * 4. For each account, reconstructs the withdrawal history by:
+     *    - Generating nullifiers sequentially
+     *    - Matching them against on-chain events
+     *    - Adding matched withdrawals to the account state
+     * 5. Adds ragequit events to accounts if found
+     *
+     * @throws {DataError} If event fetching fails
+     * @private
+     */
+    async _processWithdrawalsAndRagequits(pools) {
+        await Promise.all(pools.map(async (pool) => {
+            const accounts = this.account.poolAccounts.get(pool.scope);
+            // Skip if no accounts for this scope
+            if (!accounts || accounts.length === 0) {
+                this.logger.info(`No accounts found for pool ${pool.address} with scope ${pool.scope}`);
+                return;
+            }
+            // Find the earliest deposit block for this scope
+            let firstDepositBlock = BigInt(Number.MAX_SAFE_INTEGER);
+            for (const account of accounts) {
+                if (account.deposit.blockNumber < firstDepositBlock) {
+                    firstDepositBlock = account.deposit.blockNumber;
+                }
+            }
+            // Fetch withdrawal and ragequit events from the first deposit block
+            const withdrawals = await this.dataService.getWithdrawals(pool, firstDepositBlock);
+            const ragequits = await this.dataService.getRagequits(pool, firstDepositBlock);
+            this.logger.info(`Found ${withdrawals.length} withdrawals for pool ${pool.address}`);
+            if (withdrawals.length === 0 && ragequits.length === 0) {
+                return;
+            }
+            // Map withdrawals by spent nullifier for quick lookup
+            const withdrawalMap = new Map();
+            for (const withdrawal of withdrawals) {
+                withdrawalMap.set(withdrawal.spentNullifier, withdrawal);
+            }
+            // Map ragequits by label for quick lookup
+            const ragequitMap = new Map();
+            for (const ragequit of ragequits) {
+                ragequitMap.set(ragequit.label, ragequit);
+            }
+            // Process each account
+            for (const account of accounts) {
+                let currentCommitment = account.deposit;
+                let index = BigInt(0);
+                // Continue processing withdrawals until no more are found
+                while (true) {
+                    // Generate nullifier for this withdrawal
+                    const nullifierHash = hashingExports.poseidon([currentCommitment.nullifier]);
+                    // Look for a withdrawal event with this nullifier
+                    const withdrawal = withdrawalMap.get(nullifierHash);
+                    if (!withdrawal) {
+                        break;
                     }
-                    this.addWithdrawalCommitment(parentCommitment, withdrawal.withdrawn, withdrawal.spentNullifier, parentCommitment.secret, withdrawal.blockNumber, withdrawal.transactionHash);
-                    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++;
+                }
+                const ragequit = ragequitMap.get(account.label);
+                if (ragequit) {
+                    this.addRagequitToAccount(account.label, ragequit);
                 }
             }
-        }
+        }));
     }
 }
 
@@ -69018,15 +69214,14 @@ class DataService {
      * @returns Array of deposit events with properly typed fields (bigint for numbers, Hash for commitments)
      * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
-    async getDeposits(chainId, options = {}) {
+    async getDeposits(pool) {
         try {
-            const client = this.getClientForChain(chainId);
-            const config = this.getConfigForChain(chainId);
+            const client = this.getClientForChain(pool.chainId);
+            const config = this.getConfigForChain(pool.chainId);
             const logs = await client.getLogs({
-                address: config.privacyPoolAddress,
+                address: pool.address,
                 event: DEPOSIT_EVENT,
-                fromBlock: options.fromBlock ?? config.startBlock,
-                toBlock: options.toBlock,
+                fromBlock: pool.deploymentBlock ?? config.startBlock
             }).catch(error => {
                 throw new DataError("Failed to fetch deposit logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
             });
@@ -69059,7 +69254,7 @@ class DataService {
         catch (error) {
             if (error instanceof DataError)
                 throw error;
-            throw DataError.networkError(chainId, error instanceof Error ? error : new Error(String(error)));
+            throw DataError.networkError(pool.chainId, error instanceof Error ? error : new Error(String(error)));
         }
     }
     /**
@@ -69070,15 +69265,14 @@ class DataService {
      * @returns Array of withdrawal events with properly typed fields (bigint for numbers, Hash for commitments)
      * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
-    async getWithdrawals(chainId, options = {}) {
+    async getWithdrawals(pool, fromBlock = pool.deploymentBlock) {
         try {
-            const client = this.getClientForChain(chainId);
-            const config = this.getConfigForChain(chainId);
+            const client = this.getClientForChain(pool.chainId);
+            const config = this.getConfigForChain(pool.chainId);
             const logs = await client.getLogs({
-                address: config.privacyPoolAddress,
+                address: pool.address,
                 event: WITHDRAWAL_EVENT,
-                fromBlock: options.fromBlock ?? config.startBlock,
-                toBlock: options.toBlock,
+                fromBlock: fromBlock ?? config.startBlock,
             }).catch(error => {
                 throw new DataError("Failed to fetch withdrawal logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
             });
@@ -69109,7 +69303,7 @@ class DataService {
         catch (error) {
             if (error instanceof DataError)
                 throw error;
-            throw DataError.networkError(chainId, error instanceof Error ? error : new Error(String(error)));
+            throw DataError.networkError(pool.chainId, error instanceof Error ? error : new Error(String(error)));
         }
     }
     /**
@@ -69120,15 +69314,14 @@ class DataService {
      * @returns Array of ragequit events with properly typed fields (bigint for numbers, Hash for commitments)
      * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
-    async getRagequits(chainId, options = {}) {
+    async getRagequits(pool, fromBlock = pool.deploymentBlock) {
         try {
-            const client = this.getClientForChain(chainId);
-            const config = this.getConfigForChain(chainId);
+            const client = this.getClientForChain(pool.chainId);
+            const config = this.getConfigForChain(pool.chainId);
             const logs = await client.getLogs({
-                address: config.privacyPoolAddress,
+                address: pool.address,
                 event: RAGEQUIT_EVENT,
-                fromBlock: options.fromBlock ?? config.startBlock,
-                toBlock: options.toBlock,
+                fromBlock: fromBlock ?? config.startBlock,
             }).catch(error => {
                 throw new DataError("Failed to fetch ragequit logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
             });
@@ -69160,7 +69353,7 @@ class DataService {
         catch (error) {
             if (error instanceof DataError)
                 throw error;
-            throw DataError.networkError(chainId, error instanceof Error ? error : new Error(String(error)));
+            throw DataError.networkError(pool.chainId, error instanceof Error ? error : new Error(String(error)));
         }
     }
     getClientForChain(chainId) {
@@ -69180,4 +69373,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-B2wT3cOz.js.map
+//# sourceMappingURL=index-CGSW-te1.js.map