@0xbow/privacy-pools-core-sdk 1.0.2 → 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-bIu80opN.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-Ok2Ropox.js → fetchArtifacts.esm-IMTIZwq7.js}

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

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

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

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

@@ -51070,10 +51070,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-Ok2Ropox.js');
+        return import('./fetchArtifacts.esm-IMTIZwq7.js');
     }
     else {
-        return import('./fetchArtifacts.node-DpNFJc75.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);
@@ -76828,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,
@@ -76853,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;
@@ -76992,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
@@ -77007,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 });
@@ -77023,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);
@@ -77234,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-xpjDqElC.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.2",
+  "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/data.service.ts

@@ -24,7 +24,7 @@ const RAGEQUIT_EVENT = parseAbiItem('event Ragequit(address indexed _ragequitter
 /**
  * Service responsible for fetching and managing privacy pool events across multiple chains.
  * Handles event retrieval, parsing, and validation for deposits, withdrawals, and ragequits.
- * 
+ *
  * @remarks
  * This service uses viem's PublicClient to efficiently fetch and process blockchain events.
  * It supports multiple chains and provides robust error handling and validation.
@@ -36,7 +36,7 @@ export class DataService {
 
   /**
    * Initialize the data service with chain configurations
-   * 
+   *
    * @param chainConfigs - Array of chain configurations containing chainId, RPC URL, and API key
    * @throws {DataError} If client initialization fails for any chain
    */
@@ -50,7 +50,9 @@ export class DataService {
         }
 
         const client = createPublicClient({
-          transport: http(config.rpcUrl),
+          transport: http(config.rpcUrl, {
+            timeout: 20_000,
+          }),
         });
         this.clients.set(config.chainId, client);
       }
@@ -65,7 +67,7 @@ export class DataService {
 
   /**
    * Get deposit events for a specific chain
-   * 
+   *
    * @param chainId - Chain ID to fetch events from
    * @param options - Event filter options including fromBlock, toBlock, and other filters
    * @returns Array of deposit events with properly typed fields (bigint for numbers, Hash for commitments)
@@ -130,7 +132,7 @@ export class DataService {
 
   /**
    * Get withdrawal events for a specific chain
-   * 
+   *
    * @param chainId - Chain ID to fetch events from
    * @param options - Event filter options including fromBlock, toBlock, and other filters
    * @returns Array of withdrawal events with properly typed fields (bigint for numbers, Hash for commitments)
@@ -192,7 +194,7 @@ export class DataService {
 
   /**
    * Get ragequit events for a specific chain
-   * 
+   *
    * @param chainId - Chain ID to fetch events from
    * @param options - Event filter options including fromBlock, toBlock, and other filters
    * @returns Array of ragequit events with properly typed fields (bigint for numbers, Hash for commitments)

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;
+}
+