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

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

package/dist/types/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./commitment.js";
 export * from "./withdrawal.js";
 export * from "./keys.js";
+export * from "./rateLimit.js";

package/dist/types/types/rateLimit.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Configuration options for rate-limited log fetching
+ */
+export interface LogFetchConfig {
+    /**
+     * Maximum number of blocks to fetch in a single RPC call.
+     * Default: 10000 (typical limit for most RPC providers)
+     */
+    blockChunkSize: number;
+    /**
+     * Maximum number of concurrent log fetch operations.
+     * Default: 3
+     */
+    concurrency: number;
+    /**
+     * Delay in milliseconds between chunk requests (for additional throttling).
+     * Default: 0 (no delay)
+     */
+    chunkDelayMs: number;
+    /**
+     * Whether to retry failed chunk fetches.
+     * Default: true
+     */
+    retryOnFailure: boolean;
+    /**
+     * Maximum number of retries for a failed chunk.
+     * Default: 3
+     */
+    maxRetries: number;
+    /**
+     * Base delay for exponential backoff on retries (ms).
+     * Default: 1000
+     */
+    retryBaseDelayMs: number;
+}
+/**
+ * Default log fetch configuration
+ */
+export declare const DEFAULT_LOG_FETCH_CONFIG: LogFetchConfig;
+/**
+ * Per-chain log fetch configuration map
+ * Maps chainId to its specific LogFetchConfig
+ */
+export type ChainLogFetchConfig = Map<number, Partial<LogFetchConfig>>;
+/**
+ * Block range for chunked fetching
+ */
+export interface BlockRange {
+    fromBlock: bigint;
+    toBlock: bigint;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xbow/privacy-pools-core-sdk",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Typescript SDK for the Privacy Pool protocol",
   "repository": "https://github.com/0xbow-io/privacy-pools-core",
   "license": "Apache-2.0",
@@ -50,6 +50,8 @@
   "dependencies": {
     "@types/snarkjs": "0.7.9",
     "@zk-kit/lean-imt": "2.2.4",
+    "async": "3.2.6",
+    "dotenv": "17.3.1",
     "maci-crypto": "2.5.0",
     "snarkjs": "0.7.5",
     "typescript": "^5.7.3",
@@ -66,10 +68,10 @@
     "@rollup/plugin-node-resolve": "16.0.0",
     "@rollup/plugin-typescript": "12.1.2",
     "@rollup/plugin-wasm": "6.2.2",
+    "@types/async": "3.2.24",
     "@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

@@ -2,6 +2,7 @@ import { poseidon } from "maci-crypto/build/ts/hashing.js";
 import { Hash, Secret } from "../types/commitment.js";
 import { Hex, bytesToNumber } from "viem";
 import { mnemonicToAccount } from "viem/accounts";
+import { mapLimit } from "async";
 import { DataService } from "./data.service.js";
 import {
   AccountCommitment,
@@ -18,7 +19,6 @@ 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";
@@ -26,9 +26,11 @@ import { EventError } from "../errors/events.error.js";
 type AccountServiceConfig =
   | {
     mnemonic: string;
+    poolConcurrency?: number;
   }
   | {
     account: PrivacyPoolAccount;
+    poolConcurrency?: number;
   };
 
 /**
@@ -42,6 +44,7 @@ type AccountServiceConfig =
 export class AccountService {
   account: PrivacyPoolAccount;
   private readonly logger: Logger;
+  private readonly poolConcurrency: number;
 
   /**
    * Creates a new AccountService instance.
@@ -50,6 +53,7 @@ export class AccountService {
    * @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
+   * @param config.poolConcurrency - Optional maximum number of pools to fetch events for concurrently (default: 2)
    *
    * @throws {AccountError} If account initialization fails
    */
@@ -58,6 +62,7 @@ export class AccountService {
     config: AccountServiceConfig
   ) {
     this.logger = new Logger({ prefix: "Account" });
+    this.poolConcurrency = config.poolConcurrency ?? 2;
     if ("mnemonic" in config) {
       this.account = this._initializeAccount(config.mnemonic);
     } else {
@@ -562,44 +567,51 @@ export class AccountService {
   }
 
   /**
-   * Fetches events for a given set of pools with concurrency control
+   * Fetches events for a given set of pools
    *
    * @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[],
-    maxConcurrency: number = 5
-  ): Promise<PoolEventsResult> {
+  public async getEvents(pools: PoolInfo[]): Promise<PoolEventsResult> {
     const events: PoolEventsResult = new Map();
 
-    // 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),
-        ]);
-
-      return {
-        scope: pool.scope,
-        depositEvents,
-        withdrawalEvents,
-        ragequitEvents,
-      };
-    });
-
-    // Execute with concurrency control
-    const poolEventResults = await batchWithConcurrency(tasks, maxConcurrency);
+    // Use mapLimit to control concurrency at pool level
+    const poolEventResults = await mapLimit(
+      pools,
+      this.poolConcurrency,
+      async (pool: PoolInfo) => {
+        try {
+          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 {
+            status: "fulfilled" as const,
+            value: {
+              scope: pool.scope,
+              depositEvents,
+              withdrawalEvents,
+              ragequitEvents,
+            },
+          };
+        } catch (error) {
+          return {
+            status: "rejected" as const,
+            reason: error as Error,
+          };
+        }
+      }
+    );
 
     for (const result of poolEventResults) {
       if (result.status === "fulfilled") {
@@ -611,9 +623,12 @@ export class AccountService {
           ragequitEvents,
         });
       } else {
-        events.set(result.reason.details?.scope as Hash, {
+        const errorWithDetails = result.reason as Error & { details?: { scope?: Hash } };
+        const scope = errorWithDetails.details?.scope as Hash;
+
+        events.set(scope, {
           reason: result.reason.message,
-          scope: result.reason.details?.scope as Hash,
+          scope: scope,
         });
       }
     }
@@ -790,11 +805,10 @@ 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 (with concurrency control)
+   * 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
@@ -815,8 +829,7 @@ export class AccountService {
       | {
         service: AccountService;
       },
-    pools: PoolInfo[],
-    maxConcurrency: number = 5
+    pools: PoolInfo[]
   ): Promise<{ account: AccountService; errors: PoolEventsError[] }> {
     // Log the start of the history retrieval process
     const logger = new Logger({ prefix: "Account" });
@@ -839,7 +852,7 @@ export class AccountService {
         : { account: source.service.account }
     );
 
-    const events = await account.getEvents(pools, maxConcurrency);
+    const events = await account.getEvents(pools);
 
     for (const [scope, result] of events.entries()) {
       if ("reason" in result) {