@0xbow/privacy-pools-core-sdk 0.1.21 → 1.0.2

package/dist/types/{index-CIvuCHHq.js → index-xpjDqElC.js}

@@ -15082,19 +15082,10 @@ var __setModuleDefault = Object.create ? (function(o, v) {
     o["default"] = v;
 };
 
-var ownKeys = function(o) {
-    ownKeys = Object.getOwnPropertyNames || function (o) {
-        var ar = [];
-        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-        return ar;
-    };
-    return ownKeys(o);
-};
-
 function __importStar(mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 }
@@ -15176,25 +15167,12 @@ function __disposeResources(env) {
     return next();
 }
 
-function __rewriteRelativeImportExtension(path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-}
-
 var tslib_es6 = {
     __extends: __extends,
     __assign: __assign,
     __rest: __rest,
     __decorate: __decorate,
     __param: __param,
-    __esDecorate: __esDecorate,
-    __runInitializers: __runInitializers,
-    __propKey: __propKey,
-    __setFunctionName: __setFunctionName,
     __metadata: __metadata,
     __awaiter: __awaiter,
     __generator: __generator,
@@ -15217,7 +15195,6 @@ var tslib_es6 = {
     __classPrivateFieldIn: __classPrivateFieldIn,
     __addDisposableResource: __addDisposableResource,
     __disposeResources: __disposeResources,
-    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
 };
 
 var tslib_es6$1 = /*#__PURE__*/Object.freeze({
@@ -15247,7 +15224,6 @@ var tslib_es6$1 = /*#__PURE__*/Object.freeze({
     __propKey: __propKey,
     __read: __read,
     __rest: __rest,
-    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
     __runInitializers: __runInitializers,
     __setFunctionName: __setFunctionName,
     __spread: __spread,
@@ -50363,9 +50339,9 @@ var hashingExports = requireHashing();
 
 /**
  * @module @zk-kit/utils
- * @version 1.2.1
+ * @version 1.4.1
  * @file Essential zero-knowledge utility library for JavaScript developers.
- * @copyright Ethereum Foundation 2024
+ * @copyright Ethereum Foundation 2025
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
@@ -50415,9 +50391,9 @@ function isArray(value) {
 
 /**
  * @module @zk-kit/utils
- * @version 1.2.1
+ * @version 1.4.1
  * @file Essential zero-knowledge utility library for JavaScript developers.
- * @copyright Ethereum Foundation 2024
+ * @copyright Ethereum Foundation 2025
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/utils}
 */
@@ -50484,9 +50460,9 @@ function requireArray(parameterValue, parameterName) {
 
 /**
  * @module @zk-kit/lean-imt
- * @version 2.2.2
+ * @version 2.2.4
  * @file Lean Incremental Merkle tree implementation in TypeScript.
- * @copyright Ethereum Foundation 2024
+ * @copyright Ethereum Foundation 2025
  * @license MIT
  * @see [Github]{@link https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/lean-imt}
 */
@@ -50617,7 +50593,7 @@ class LeanIMT {
             throw new Error("There are no leaves to add");
         }
         let startIndex = this.size >> 1;
-        this._nodes[0].push(...leaves);
+        this._nodes[0] = this._nodes[0].concat(leaves);
         // Calculate how many tree levels will need to be added
         // using the number of leaves.
         const numberOfNewLevels = Math.ceil(Math.log2(this.size)) - this.depth;
@@ -50748,7 +50724,12 @@ class LeanIMT {
         }
         // The index might be different from the original index of the leaf, since
         // in some cases some siblings are not included (as explained above).
-        return { root: this.root, leaf, index: Number.parseInt(path.reverse().join(""), 2), siblings };
+        return {
+            root: this.root,
+            leaf,
+            index: path.length === 0 ? 0 : Number.parseInt(path.reverse().join(""), 2),
+            siblings
+        };
     }
     /**
      * It verifies a {@link LeanIMTMerkleProof} to confirm that a leaf indeed
@@ -50956,7 +50937,14 @@ function generateMerkleProof(leaves, leaf) {
     if (leafIndex === -1) {
         throw new PrivacyPoolError(ErrorCode$1.MERKLE_ERROR, "Leaf not found in the leaves array.");
     }
-    return tree.generateProof(leafIndex);
+    const proof = tree.generateProof(leafIndex);
+    if (proof.siblings.length < 32) {
+        proof.siblings = [
+            ...proof.siblings,
+            ...Array(32 - proof.siblings.length).fill(BigInt(0)),
+        ];
+    }
+    return proof;
 }
 function bigintToHash(value) {
     return `0x${value.toString(16).padStart(64, "0")}`;
@@ -51082,10 +51070,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-CxFhH8oR.js');
+        return import('./fetchArtifacts.esm-Ok2Ropox.js');
     }
     else {
-        return import('./fetchArtifacts.node-Cqk_Z-mS.js');
+        return import('./fetchArtifacts.node-DpNFJc75.js');
     }
 }
 
@@ -53222,6 +53210,9 @@ class ContractError extends SDKError {
     static scopeNotFound(scope) {
         return new ContractError(`No pool found for scope ${scope.toString()}`, ErrorCode.CONTRACT_ERROR);
     }
+    static assetNotFound(address) {
+        return new ContractError(`Asset ${address} has no pool`, ErrorCode.CONTRACT_ERROR);
+    }
 }
 
 class ContractInteractionsService {
@@ -53430,6 +53421,34 @@ class ContractInteractionsService {
         });
         return BigInt(stateSize);
     }
+    /**
+     * Retrieves data from the corresponding asset
+     *
+     * @param assetAddress - The asset contract address.
+     * @returns AssetConfig - An object containing the privacy pool address, minimum deposit amount, vetting fee and maximum relaying fee.
+     * @throws ContractError if the asset does not exist in the pool.
+     */
+    async getAssetConfig(assetAddress) {
+        const assetConfig = await this.publicClient.readContract({
+            address: this.entrypointAddress,
+            abi: IEntrypointABI,
+            account: this.account,
+            args: [assetAddress],
+            functionName: "assetConfig",
+        });
+        const [pool, minimumDepositAmount, vettingFeeBPS, maxRelayFeeBPS] = assetConfig;
+        // if no pool throw error
+        if (!pool ||
+            pool === "0x0000000000000000000000000000000000000000") {
+            throw ContractError.assetNotFound(assetAddress);
+        }
+        return {
+            pool: getAddress(pool),
+            minimumDepositAmount,
+            vettingFeeBPS,
+            maxRelayFeeBPS
+        };
+    }
     /**
      * Retrieves data about a specific scope, including the associated privacy pool
      * and the asset used in that pool.
@@ -76209,6 +76228,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,
@@ -76218,10 +76253,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
@@ -76301,6 +76336,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;
@@ -76344,6 +76385,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.
@@ -76360,15 +76433,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.
@@ -76396,7 +76475,7 @@ class AccountService {
                 masterKeys: [masterNullifier, masterSecret],
                 poolAccounts: new Map(),
                 creationTimestamp: 0n,
-                lastUpdateTimestamp: 0n
+                lastUpdateTimestamp: 0n,
             };
         }
         catch (error) {
@@ -76518,8 +76597,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);
@@ -76677,6 +76759,288 @@ 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) {
+                const existingEvent = depositMap.get(event.precommitment);
+                // If no existing event, or current event is older (earlier block), use current event
+                if (!existingEvent || event.blockNumber < existingEvent.blockNumber) {
+                    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) {
+        const MAX_CONSECUTIVE_MISSES = 10; // Large enough to avoid tx failures
+        const foundIndices = new Set();
+        let consecutiveMisses = 0;
+        for (let index = BigInt(0);; 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) {
+                consecutiveMisses++;
+                if (consecutiveMisses >= MAX_CONSECUTIVE_MISSES) {
+                    break;
+                }
+                continue;
+            }
+            // Can reset counter in case if user had any tx failures for
+            // newer deposits
+            consecutiveMisses = 0;
+            foundIndices.add(index);
+            // Create a new pool account for this deposit
+            this.addPoolAccount(scope, event.value, nullifier, secret, event.label, event.blockNumber, event.transactionHash);
+            this.logger.debug(`Found deposit at index ${index} for scope ${scope}`);
+        }
+    }
+    /**
+     * 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
@@ -76811,7 +77175,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) {
@@ -76836,22 +77202,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)');
@@ -76880,12 +77230,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);
             }

package/dist/types/index.js

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