@0xbow/privacy-pools-core-sdk 1.0.3 → 1.0.4

package/dist/node/index.mjs

@@ -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-DB1uYJPF.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-DGsIfUGw.js';
 import 'viem/accounts';
 import 'buffer';
 import 'http';

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

@@ -223,13 +223,14 @@ export declare class AccountService {
      */
     getRagequitEvents(pool: PoolInfo): Promise<Map<Hash, RagequitEvent>>;
     /**
-     * Fetches events for a given set of pools
+     * Fetches events for a given set of pools with concurrency control
      *
      * @param pools - The pools to fetch events for
+     * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
      *
      * @returns A map of pool scopes to their events
      */
-    getEvents(pools: PoolInfo[]): Promise<PoolEventsResult>;
+    getEvents(pools: PoolInfo[], maxConcurrency?: number): Promise<PoolEventsResult>;
     /**
      * 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
@@ -279,10 +280,11 @@ export declare class AccountService {
      * @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
+     * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
      *
      * @remarks
      * This method performs the following steps for each pool:
-     * 1. Fetches deposit, withdrawal, and ragequit events for each pool
+     * 1. Fetches deposit, withdrawal, and ragequit events for each pool (with concurrency control)
      * 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
@@ -298,7 +300,7 @@ export declare class AccountService {
         mnemonic: string;
     } | {
         service: AccountService;
-    }, pools: PoolInfo[]): Promise<{
+    }, pools: PoolInfo[], maxConcurrency?: number): Promise<{
         account: AccountService;
         errors: PoolEventsError[];
     }>;

package/dist/types/{fetchArtifacts.esm-CzBDJOwj.js → fetchArtifacts.esm-IMTIZwq7.js}

@@ -1,4 +1,4 @@
-import { F as FetchArtifact } from './index-BL6xN-P5.js';
+import { F as FetchArtifact } from './index-DbuAhDci.js';
 import 'viem/accounts';
 import 'buffer';
 import 'http';

package/dist/types/{fetchArtifacts.node-CtMsXhR9.js → fetchArtifacts.node-BcXsBNCT.js}

@@ -1,4 +1,4 @@
-import { F as FetchArtifact } from './index-BL6xN-P5.js';
+import { F as FetchArtifact } from './index-DbuAhDci.js';
 import 'viem/accounts';
 import 'buffer';
 import 'http';

package/dist/types/{index-BL6xN-P5.js → index-DbuAhDci.js}

@@ -51070,10 +51070,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-CzBDJOwj.js');
+        return import('./fetchArtifacts.esm-IMTIZwq7.js');
     }
     else {
-        return import('./fetchArtifacts.node-CtMsXhR9.js');
+        return import('./fetchArtifacts.node-BcXsBNCT.js');
     }
 }
 
@@ -76385,6 +76385,31 @@ class Logger {
     }
 }
 
+/**
+ * Executes an array of promise-returning functions with a maximum concurrency limit.
+ * This prevents overwhelming RPC endpoints with too many concurrent requests.
+ *
+ * @param tasks - Array of functions that return promises
+ * @param maxConcurrency - Maximum number of concurrent executions (default: 5)
+ * @returns Promise that resolves to an array of settled results
+ *
+ * @example
+ * ```typescript
+ * const tasks = pools.map(pool => () => fetchPoolData(pool));
+ * const results = await batchWithConcurrency(tasks, 5);
+ * ```
+ */
+async function batchWithConcurrency(tasks, maxConcurrency = 5) {
+    const results = [];
+    // Process tasks in batches
+    for (let i = 0; i < tasks.length; i += maxConcurrency) {
+        const batch = tasks.slice(i, i + maxConcurrency);
+        const batchResults = await Promise.allSettled(batch.map(task => task()));
+        results.push(...batchResults);
+    }
+    return results;
+}
+
 class DataError extends SDKError {
     constructor(message, code = ErrorCode.NETWORK_ERROR, details) {
         super(message, code, details);
@@ -76441,7 +76466,7 @@ class AccountService {
      */
     constructor(dataService, config) {
         this.dataService = dataService;
-        this.logger = new Logger({ prefix: "Account", level: LogLevel.DEBUG });
+        this.logger = new Logger({ prefix: "Account" });
         if ("mnemonic" in config) {
             this.account = this._initializeAccount(config.mnemonic);
         }
@@ -76656,12 +76681,6 @@ class AccountService {
     addPoolAccount(scope, value, nullifier, secret, label, blockNumber, txHash) {
         const precommitment = this._hashPrecommitment(nullifier, secret);
         const commitment = this._hashCommitment(value, label, precommitment);
-        this.logger.debug(`Commitment calculation details`, {
-            value,
-            label,
-            precommitment,
-            commitment,
-        });
         const newAccount = {
             label,
             deposit: {
@@ -76727,7 +76746,6 @@ class AccountService {
             blockNumber,
             txHash,
         };
-        this.logger.debug(`adding the following commitment`, { precommitment, hash: this._hashCommitment(value, parentCommitment.label, precommitment), });
         foundAccount.children.push(newCommitment);
         this.logger.info(`Added new commitment with value ${value} to account with label ${parentCommitment.label}`);
         return newCommitment;
@@ -76835,15 +76853,17 @@ class AccountService {
         }
     }
     /**
-     * Fetches events for a given set of pools
+     * Fetches events for a given set of pools with concurrency control
      *
      * @param pools - The pools to fetch events for
+     * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
      *
      * @returns A map of pool scopes to their events
      */
-    async getEvents(pools) {
+    async getEvents(pools, maxConcurrency = 5) {
         const events = new Map();
-        const poolEventResults = await Promise.allSettled(pools.map(async (pool) => {
+        // Create tasks for batched execution
+        const tasks = pools.map((pool) => async () => {
             this.logger.info(`Fetching events for pool`, {
                 poolAddress: pool.address,
                 poolChainId: pool.chainId,
@@ -76860,7 +76880,9 @@ class AccountService {
                 withdrawalEvents,
                 ragequitEvents,
             };
-        }));
+        });
+        // Execute with concurrency control
+        const poolEventResults = await batchWithConcurrency(tasks, maxConcurrency);
         for (const result of poolEventResults) {
             if (result.status === "fulfilled") {
                 const { scope, depositEvents, withdrawalEvents, ragequitEvents } = result.value;
@@ -76999,10 +77021,11 @@ class AccountService {
      * @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
+     * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
      *
      * @remarks
      * This method performs the following steps for each pool:
-     * 1. Fetches deposit, withdrawal, and ragequit events for each pool
+     * 1. Fetches deposit, withdrawal, and ragequit events for each pool (with concurrency control)
      * 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
@@ -77014,7 +77037,7 @@ class AccountService {
      *
      * @throws {AccountError} If account state reconstruction fails or if duplicate pools are found
      */
-    static async initializeWithEvents(dataService, source, pools) {
+    static async initializeWithEvents(dataService, source, pools, maxConcurrency = 5) {
         // Log the start of the history retrieval process
         const logger = new Logger({ prefix: "Account" });
         logger.info(`Fetching events for pools`, { poolLength: pools.length });
@@ -77030,7 +77053,7 @@ class AccountService {
         const account = new AccountService(dataService, "mnemonic" in source
             ? { mnemonic: source.mnemonic }
             : { account: source.service.account });
-        const events = await account.getEvents(pools);
+        const events = await account.getEvents(pools, maxConcurrency);
         for (const [scope, result] of events.entries()) {
             if ("reason" in result) {
                 errors.push(result);
@@ -77241,7 +77264,9 @@ class DataService {
                     throw new Error(`Missing RPC URL for chain ${config.chainId}`);
                 }
                 const client = createPublicClient({
-                    transport: http(config.rpcUrl),
+                    transport: http(config.rpcUrl, {
+                        timeout: 20_000,
+                    }),
                 });
                 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-BL6xN-P5.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-DbuAhDci.js';
 import 'viem/accounts';
 import 'buffer';
 import 'http';

package/dist/types/utils/concurrency.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Executes an array of promise-returning functions with a maximum concurrency limit.
+ * This prevents overwhelming RPC endpoints with too many concurrent requests.
+ *
+ * @param tasks - Array of functions that return promises
+ * @param maxConcurrency - Maximum number of concurrent executions (default: 5)
+ * @returns Promise that resolves to an array of settled results
+ *
+ * @example
+ * ```typescript
+ * const tasks = pools.map(pool => () => fetchPoolData(pool));
+ * const results = await batchWithConcurrency(tasks, 5);
+ * ```
+ */
+export declare function batchWithConcurrency<T>(tasks: (() => Promise<T>)[], maxConcurrency?: number): Promise<PromiseSettledResult<T>[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xbow/privacy-pools-core-sdk",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Typescript SDK for the Privacy Pool protocol",
   "repository": "https://github.com/0xbow-io/privacy-pools-core",
   "license": "Apache-2.0",
@@ -69,6 +69,7 @@
     "@types/node": "20.3.1",
     "@types/snarkjs": "0.7.9",
     "commitlint": "19.4.1",
+    "dotenv": "^17.3.1",
     "globals": "15.14.0",
     "husky": "9.1.5",
     "lint-staged": "15.2.10",

package/src/core/account.service.ts

@@ -18,6 +18,7 @@ import {
 } from "../types/events.js";
 
 import { Logger } from "../utils/logger.js";
+import { batchWithConcurrency } from "../utils/concurrency.js";
 import { AccountError } from "../errors/account.error.js";
 import { ErrorCode } from "../errors/base.error.js";
 import { EventError } from "../errors/events.error.js";
@@ -561,38 +562,44 @@ export class AccountService {
   }
 
   /**
-   * Fetches events for a given set of pools
+   * Fetches events for a given set of pools with concurrency control
    *
    * @param pools - The pools to fetch events for
+   * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
    *
    * @returns A map of pool scopes to their events
    */
-  public async getEvents(pools: PoolInfo[]): Promise<PoolEventsResult> {
+  public async getEvents(
+    pools: PoolInfo[],
+    maxConcurrency: number = 5
+  ): Promise<PoolEventsResult> {
     const events: PoolEventsResult = 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,
-        });
+    // Create tasks for batched execution
+    const tasks = pools.map((pool) => async () => {
+      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),
-          ]);
+      const [depositEvents, withdrawalEvents, ragequitEvents] =
+        await Promise.all([
+          this.getDepositEvents(pool),
+          this.getWithdrawalEvents(pool),
+          this.getRagequitEvents(pool),
+        ]);
 
-        return {
-          scope: pool.scope,
-          depositEvents,
-          withdrawalEvents,
-          ragequitEvents,
-        };
-      })
-    );
+      return {
+        scope: pool.scope,
+        depositEvents,
+        withdrawalEvents,
+        ragequitEvents,
+      };
+    });
+
+    // Execute with concurrency control
+    const poolEventResults = await batchWithConcurrency(tasks, maxConcurrency);
 
     for (const result of poolEventResults) {
       if (result.status === "fulfilled") {
@@ -783,10 +790,11 @@ export class AccountService {
    * @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
+   * @param maxConcurrency - Maximum number of concurrent pool fetches (default: 5)
    *
    * @remarks
    * This method performs the following steps for each pool:
-   * 1. Fetches deposit, withdrawal, and ragequit events for each pool
+   * 1. Fetches deposit, withdrawal, and ragequit events for each pool (with concurrency control)
    * 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
@@ -807,7 +815,8 @@ export class AccountService {
       | {
         service: AccountService;
       },
-    pools: PoolInfo[]
+    pools: PoolInfo[],
+    maxConcurrency: number = 5
   ): Promise<{ account: AccountService; errors: PoolEventsError[] }> {
     // Log the start of the history retrieval process
     const logger = new Logger({ prefix: "Account" });
@@ -830,7 +839,7 @@ export class AccountService {
         : { account: source.service.account }
     );
 
-    const events = await account.getEvents(pools);
+    const events = await account.getEvents(pools, maxConcurrency);
 
     for (const [scope, result] of events.entries()) {
       if ("reason" in result) {

package/src/core/contracts.service.ts

@@ -55,17 +55,13 @@ export class ContractInteractionsService implements ContractInteractions {
 
     this.walletClient = createWalletClient({
       chain: chain,
-      transport: http(rpcUrl, {
-        timeout: 20_000,
-      }),
+      transport: http(rpcUrl),
       account: this.account,
     });
 
     this.publicClient = createPublicClient({
       chain: chain,
-      transport: http(rpcUrl, {
-        timeout: 20_000,
-      }),
+      transport: http(rpcUrl),
     });
 
     this.entrypointAddress = entrypointAddress;

package/src/providers/blockchainProvider.ts

@@ -15,9 +15,7 @@ export class BlockchainProvider implements IBlockchainProvider {
 
     this.client = createPublicClient({
       chain: mainnet,
-      transport: http(rpcUrl, {
-        timeout: 20_000,
-      }),
+      transport: http(rpcUrl),
     });
   }
 

package/src/utils/concurrency.ts

@@ -0,0 +1,32 @@
+/**
+ * Executes an array of promise-returning functions with a maximum concurrency limit.
+ * This prevents overwhelming RPC endpoints with too many concurrent requests.
+ *
+ * @param tasks - Array of functions that return promises
+ * @param maxConcurrency - Maximum number of concurrent executions (default: 5)
+ * @returns Promise that resolves to an array of settled results
+ *
+ * @example
+ * ```typescript
+ * const tasks = pools.map(pool => () => fetchPoolData(pool));
+ * const results = await batchWithConcurrency(tasks, 5);
+ * ```
+ */
+export async function batchWithConcurrency<T>(
+  tasks: (() => Promise<T>)[],
+  maxConcurrency: number = 5
+): Promise<PromiseSettledResult<T>[]> {
+  const results: PromiseSettledResult<T>[] = [];
+
+  // Process tasks in batches
+  for (let i = 0; i < tasks.length; i += maxConcurrency) {
+    const batch = tasks.slice(i, i + maxConcurrency);
+    const batchResults = await Promise.allSettled(
+      batch.map(task => task())
+    );
+    results.push(...batchResults);
+  }
+
+  return results;
+}
+