@0xbow/privacy-pools-core-sdk 0.1.11 → 0.1.12

package/dist/esm/{fetchArtifacts.esm-B8U6icK3.js → fetchArtifacts.esm-Cykfrm5S.js}

@@ -1,10 +1,9 @@
-import { F as FetchArtifact } from './index-BLHTvD4r.js';
+import { F as FetchArtifact } from './index-CWlKxlGD.js';
 import 'viem/accounts';
 import 'buffer';
 import 'assert';
 import 'viem';
 import 'viem/chains';
-import '@envio-dev/hypersync-client';
 
 async function fetchVersionedArtifact(artifactUrl) {
     const res = await fetch(artifactUrl);
@@ -16,4 +15,4 @@ async function fetchVersionedArtifact(artifactUrl) {
 }
 
 export { fetchVersionedArtifact };
-//# sourceMappingURL=fetchArtifacts.esm-B8U6icK3.js.map
+//# sourceMappingURL=fetchArtifacts.esm-Cykfrm5S.js.map

package/dist/esm/fetchArtifacts.esm-Cykfrm5S.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchArtifacts.esm-Cykfrm5S.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-D8glxBXj.js → fetchArtifacts.node-D5S1JvH1.js}

@@ -1,10 +1,9 @@
-import { F as FetchArtifact } from './index-BLHTvD4r.js';
+import { F as FetchArtifact } from './index-CWlKxlGD.js';
 import 'viem/accounts';
 import 'buffer';
 import 'assert';
 import 'viem';
 import 'viem/chains';
-import '@envio-dev/hypersync-client';
 
 async function fetchVersionedArtifact(artifactUrl) {
     try {
@@ -29,4 +28,4 @@ async function fetchVersionedArtifact(artifactUrl) {
 }
 
 export { fetchVersionedArtifact };
-//# sourceMappingURL=fetchArtifacts.node-D8glxBXj.js.map
+//# sourceMappingURL=fetchArtifacts.node-D5S1JvH1.js.map

package/dist/esm/fetchArtifacts.node-D5S1JvH1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchArtifacts.node-D5S1JvH1.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-BLHTvD4r.js → index-CWlKxlGD.js}

@@ -1,9 +1,8 @@
 import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 import require$$0 from 'buffer';
 import require$$2 from 'assert';
-import { keccak256, encodeAbiParameters, numberToHex, createPublicClient, http, createWalletClient, getAddress, bytesToNumber as bytesToNumber$1 } from 'viem';
+import { keccak256, encodeAbiParameters, numberToHex, createPublicClient, http, createWalletClient, getAddress, bytesToNumber as bytesToNumber$1, parseAbiItem } from 'viem';
 import { mainnet } from 'viem/chains';
-import { HypersyncClient, presetQueryLogsOfEvent } from '@envio-dev/hypersync-client';
 
 const version = '2.22.14';
 
@@ -45816,10 +45815,10 @@ const circuitToAsset = {
 
 async function importFetchVersionedArtifact(isBrowser) {
     if (isBrowser) {
-        return import('./fetchArtifacts.esm-B8U6icK3.js');
+        return import('./fetchArtifacts.esm-Cykfrm5S.js');
     }
     else {
-        return import('./fetchArtifacts.node-D8glxBXj.js');
+        return import('./fetchArtifacts.node-D5S1JvH1.js');
     }
 }
 
@@ -68678,12 +68677,12 @@ class AccountService {
     _initializeAccount(mnemonic) {
         try {
             this.logger.debug("Initializing account with mnemonic");
-            let key1 = bytesToNumber$1(mnemonicToAccount(mnemonic, { accountIndex: 0 }).getHdKey().privateKey);
-            let key2 = bytesToNumber$1(mnemonicToAccount(mnemonic, { accountIndex: 1 }).getHdKey().privateKey);
-            let masterKey1 = hashingExports.poseidon([BigInt(key1)]);
-            let masterKey2 = hashingExports.poseidon([BigInt(key2)]);
+            let masterNullifierSeed = bytesToNumber$1(mnemonicToAccount(mnemonic, { accountIndex: 0 }).getHdKey().privateKey);
+            let masterSecretSeed = bytesToNumber$1(mnemonicToAccount(mnemonic, { accountIndex: 1 }).getHdKey().privateKey);
+            let masterNullifier = hashingExports.poseidon([BigInt(masterNullifierSeed)]);
+            let masterSecret = hashingExports.poseidon([BigInt(masterSecretSeed)]);
             return {
-                masterKeys: [masterKey1, masterKey2],
+                masterKeys: [masterNullifier, masterSecret],
                 poolAccounts: new Map(),
                 creationTimestamp: 0n,
                 lastUpdateTimestamp: 0n
@@ -68694,16 +68693,20 @@ class AccountService {
         }
     }
     _genDepositNullifier(scope, index) {
-        return hashingExports.poseidon([this.account.masterKeys[0], scope, index]);
+        const [masterNullifier] = this.account.masterKeys;
+        return hashingExports.poseidon([masterNullifier, scope, index]);
     }
     _genDepositSecret(scope, index) {
-        return hashingExports.poseidon([this.account.masterKeys[1], scope, index]);
+        const [, masterSecret] = this.account.masterKeys;
+        return hashingExports.poseidon([masterSecret, scope, index]);
     }
     _genWithdrawalNullifier(label, index) {
-        return hashingExports.poseidon([this.account.masterKeys[0], label, index]);
+        const [masterNullifier] = this.account.masterKeys;
+        return hashingExports.poseidon([masterNullifier, label, index]);
     }
     _genWithdrawalSecret(label, index) {
-        return hashingExports.poseidon([this.account.masterKeys[1], label, index]);
+        const [, masterSecret] = this.account.masterKeys;
+        return hashingExports.poseidon([masterSecret, label, index]);
     }
     _hashCommitment(value, label, precommitment) {
         return hashingExports.poseidon([value, label, precommitment]);
@@ -68865,35 +68868,6 @@ class AccountService {
         this.logger.info(`Added new commitment with value ${value} to account with label ${parentCommitment.label}`);
         return newCommitment;
     }
-    /**
-     * Process withdrawals for a given chain and block range
-     *
-     * @param chainId - The chain ID to process withdrawals for
-     * @param fromBlock - The starting block number
-     * @param foundAccounts - Map of accounts indexed by label
-     */
-    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;
-                    }
-                    this.addWithdrawalCommitment(parentCommitment, withdrawal.withdrawn, withdrawal.spentNullifier, parentCommitment.secret, withdrawal.blockNumber, withdrawal.timestamp, withdrawal.transactionHash);
-                    break;
-                }
-            }
-        }
-    }
     /**
      * Retrieves the history of deposits and withdrawals for the given pools.
      *
@@ -68959,6 +68933,28 @@ class AccountService {
             await this._processWithdrawals(pool.chainId, firstDepositBlock, accountMap);
         }));
     }
+    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;
+                    }
+                    this.addWithdrawalCommitment(parentCommitment, withdrawal.withdrawn, withdrawal.spentNullifier, parentCommitment.secret, withdrawal.blockNumber, withdrawal.timestamp, withdrawal.transactionHash);
+                    break;
+                }
+            }
+        }
+    }
 }
 
 class DataError extends SDKError {
@@ -68977,13 +68973,18 @@ class DataError extends SDKError {
     }
 }
 
+// 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)');
+const RAGEQUIT_EVENT = parseAbiItem('event Ragequit(address indexed _ragequitter, uint256 _commitment, uint256 _label, uint256 _value)');
 /**
  * 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 HypersyncClient to efficiently fetch and process blockchain events.
+ * This service uses viem's PublicClient to efficiently fetch and process blockchain events.
  * It supports multiple chains and provides robust error handling and validation.
+ * All uint256 values from events are handled as bigints, with Hash type assertions for commitment-related fields.
  */
 class DataService {
     chainConfigs;
@@ -68992,7 +68993,7 @@ class DataService {
     /**
      * Initialize the data service with chain configurations
      *
-     * @param chainConfigs - Array of chain configurations
+     * @param chainConfigs - Array of chain configurations containing chainId, RPC URL, and API key
      * @throws {DataError} If client initialization fails for any chain
      */
     constructor(chainConfigs) {
@@ -69000,96 +69001,67 @@ class DataService {
         this.logger = new Logger({ prefix: "Data" });
         try {
             for (const config of chainConfigs) {
-                const client = HypersyncClient.new({
-                    url: this.getHypersyncUrlForChain(config.chainId),
+                if (!config.rpcUrl || !config.apiKey) {
+                    throw new Error(`Missing RPC URL or API key for chain ${config.chainId}`);
+                }
+                const client = createPublicClient({
+                    transport: http(config.rpcUrl),
+                    key: config.apiKey,
                 });
                 this.clients.set(config.chainId, client);
             }
         }
         catch (error) {
-            throw new DataError("Failed to initialize HypersyncClient", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
+            throw new DataError("Failed to initialize PublicClient", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
         }
     }
     /**
-     * Get deposits for a specific chain
+     * Get deposit events for a specific chain
      *
-     * @param chainId - Chain ID to fetch deposits from
-     * @param options - Event filter options
-     * @returns Array of deposit events
-     * @throws {DataError} If client is not configured or network error occurs
+     * @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)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
     async getDeposits(chainId, options = {}) {
         try {
             const client = this.getClientForChain(chainId);
             const config = this.getConfigForChain(chainId);
-            const fromBlock = options.fromBlock ?? config.startBlock;
-            const toBlock = options.toBlock ?? undefined;
-            this.logger.debug(`Fetching deposits for chain ${chainId} from block ${fromBlock}${toBlock ? ` to ${toBlock}` : ""}`);
-            const query = presetQueryLogsOfEvent(config.privacyPoolAddress, 
-            // topic0 is keccak256("Deposited(address,uint256,uint256,uint256,uint256)")
-            "0xe3b53cd1a44fbf11535e145d80b8ef1ed6d57a73bf5daa7e939b6b01657d6549", Number(fromBlock), toBlock ? Number(toBlock) : undefined);
-            if (options.depositor) {
-                const queryWithTopics = query;
-                const topic0 = queryWithTopics.topics[0];
-                if (!topic0) {
-                    throw DataError.invalidLog("deposit", "missing topic0");
-                }
-                queryWithTopics.topics = [
-                    topic0,
-                    `0x000000000000000000000000${options.depositor.slice(2)}`,
-                ];
-            }
-            const res = await client.get(query);
-            // Create a map of block numbers to timestamps
-            const blockTimestamps = new Map(res.data.blocks.map(block => [
-                block.number,
-                block.timestamp ? BigInt(block.timestamp) : 0n
-            ]));
-            return res.data.logs.map((log) => {
-                let a = log;
-                if (!log.topics || log.topics.length < 2) {
-                    throw DataError.invalidLog("deposit", "missing topics");
-                }
-                const depositorTopic = log.topics[1];
-                if (!depositorTopic) {
-                    throw DataError.invalidLog("deposit", "missing depositor topic");
-                }
-                const depositor = BigInt(depositorTopic);
-                if (!log.data) {
-                    throw DataError.invalidLog("deposit", "missing data");
-                }
-                const data = log.data.slice(2).match(/.{64}/g);
-                if (!data || data.length < 4) {
-                    throw DataError.invalidLog("deposit", "insufficient data");
-                }
-                const commitment = BigInt("0x" + data[0]);
-                const label = BigInt("0x" + data[1]);
-                const value = BigInt("0x" + data[2]);
-                const precommitment = BigInt("0x" + data[3]);
-                if (!depositor ||
-                    !commitment ||
-                    !label ||
-                    !value ||
-                    !log.blockNumber ||
-                    !log.transactionHash) {
-                    throw DataError.invalidLog("deposit", "missing required fields");
+            const logs = await client.getLogs({
+                address: config.privacyPoolAddress,
+                event: DEPOSIT_EVENT,
+                fromBlock: options.fromBlock ?? config.startBlock,
+                toBlock: options.toBlock,
+            }).catch(error => {
+                throw new DataError("Failed to fetch deposit logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
+            });
+            return await Promise.all(logs.map(async (log) => {
+                try {
+                    const block = await client.getBlock({ blockNumber: log.blockNumber });
+                    if (!log.args) {
+                        throw DataError.invalidLog("deposit", "missing args");
+                    }
+                    const { _depositor: depositor, _commitment: commitment, _label: label, _value: value, _merkleRoot: precommitment, } = log.args;
+                    if (!depositor || !commitment || !label || !value || !precommitment || !log.blockNumber || !log.transactionHash) {
+                        throw DataError.invalidLog("deposit", "missing required fields");
+                    }
+                    return {
+                        depositor: depositor.toLowerCase(),
+                        commitment: commitment,
+                        label: label,
+                        value,
+                        precommitment: precommitment,
+                        blockNumber: BigInt(log.blockNumber),
+                        timestamp: BigInt(block.timestamp),
+                        transactionHash: log.transactionHash,
+                    };
                 }
-                const blockNumber = BigInt(log.blockNumber);
-                const timestamp = blockTimestamps.get(Number(blockNumber));
-                if (!timestamp) {
-                    throw DataError.invalidLog("deposit", "missing block timestamp");
+                catch (error) {
+                    if (error instanceof DataError)
+                        throw error;
+                    throw DataError.invalidLog("deposit", error instanceof Error ? error.message : "Unknown error");
                 }
-                return {
-                    depositor: `0x${depositor.toString(16).padStart(40, "0")}`,
-                    commitment: bigintToHash(commitment),
-                    label: bigintToHash(label),
-                    value,
-                    precommitment: bigintToHash(precommitment),
-                    blockNumber,
-                    timestamp,
-                    transactionHash: log.transactionHash,
-                };
-            });
+            }));
         }
         catch (error) {
             if (error instanceof DataError)
@@ -69098,69 +69070,50 @@ class DataService {
         }
     }
     /**
-     * Get withdrawals for a specific chain
+     * Get withdrawal events for a specific chain
      *
-     * @param chainId - Chain ID to fetch withdrawals from
-     * @param options - Event filter options
-     * @returns Array of withdrawal events
-     * @throws {DataError} If client is not configured or network error occurs
+     * @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)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
     async getWithdrawals(chainId, options = {}) {
         try {
             const client = this.getClientForChain(chainId);
             const config = this.getConfigForChain(chainId);
-            const fromBlock = options.fromBlock ?? config.startBlock;
-            const toBlock = options.toBlock ?? undefined;
-            this.logger.debug(`Fetching withdrawals for chain ${chainId} from block ${fromBlock}${toBlock ? ` to ${toBlock}` : ""}`);
-            const query = presetQueryLogsOfEvent(config.privacyPoolAddress, 
-            // topic0 is keccak256("Withdrawn(address,uint256,uint256,uint256)")
-            "0x75e161b3e824b114fc1a33274bd7091918dd4e639cede50b78b15a4eea956a21", Number(fromBlock), toBlock ? Number(toBlock) : undefined);
-            const res = await client.get(query);
-            // Create a map of block numbers to timestamps
-            const blockTimestamps = new Map(res.data.blocks.map(block => [
-                block.number,
-                block.timestamp ? BigInt(block.timestamp) : 0n
-            ]));
-            return res.data.logs.map((log) => {
-                if (!log.topics || log.topics.length < 2) {
-                    throw DataError.invalidLog("withdrawal", "missing topics");
-                }
-                const processorTopic = log.topics[1];
-                if (!processorTopic) {
-                    throw DataError.invalidLog("withdrawal", "missing processor topic");
-                }
-                const processor = BigInt(processorTopic);
-                if (!log.data) {
-                    throw DataError.invalidLog("withdrawal", "missing data");
-                }
-                const data = log.data.slice(2).match(/.{64}/g);
-                if (!data || data.length < 3) {
-                    throw DataError.invalidLog("withdrawal", "insufficient data");
-                }
-                const value = BigInt("0x" + data[0]);
-                const spentNullifier = BigInt("0x" + data[1]);
-                const newCommitment = BigInt("0x" + data[2]);
-                if (!value ||
-                    !spentNullifier ||
-                    !newCommitment ||
-                    !log.blockNumber ||
-                    !log.transactionHash) {
-                    throw DataError.invalidLog("withdrawal", "missing required fields");
+            const logs = await client.getLogs({
+                address: config.privacyPoolAddress,
+                event: WITHDRAWAL_EVENT,
+                fromBlock: options.fromBlock ?? config.startBlock,
+                toBlock: options.toBlock,
+            }).catch(error => {
+                throw new DataError("Failed to fetch withdrawal logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
+            });
+            return await Promise.all(logs.map(async (log) => {
+                try {
+                    const block = await client.getBlock({ blockNumber: log.blockNumber });
+                    if (!log.args) {
+                        throw DataError.invalidLog("withdrawal", "missing args");
+                    }
+                    const { _value: value, _spentNullifier: spentNullifier, _newCommitment: newCommitment, } = log.args;
+                    if (!value || !spentNullifier || !newCommitment || !log.blockNumber || !log.transactionHash) {
+                        throw DataError.invalidLog("withdrawal", "missing required fields");
+                    }
+                    return {
+                        withdrawn: value,
+                        spentNullifier: spentNullifier,
+                        newCommitment: newCommitment,
+                        blockNumber: BigInt(log.blockNumber),
+                        timestamp: BigInt(block.timestamp),
+                        transactionHash: log.transactionHash,
+                    };
                 }
-                const blockNumber = BigInt(log.blockNumber);
-                const timestamp = blockTimestamps.get(Number(blockNumber));
-                if (!timestamp) {
-                    throw DataError.invalidLog("withdrawal", "missing block timestamp");
+                catch (error) {
+                    if (error instanceof DataError)
+                        throw error;
+                    throw DataError.invalidLog("withdrawal", error instanceof Error ? error.message : "Unknown error");
                 }
-                return {
-                    withdrawn: value,
-                    spentNullifier: bigintToHash(spentNullifier),
-                    newCommitment: bigintToHash(newCommitment),
-                    blockNumber,
-                    timestamp,
-                    transactionHash: log.transactionHash,
-                };
-            });
+            }));
         }
         catch (error) {
             if (error instanceof DataError)
@@ -69171,100 +69124,49 @@ class DataService {
     /**
      * Get ragequit events for a specific chain
      *
-     * @param chainId - Chain ID to fetch ragequits from
-     * @param options - Event filter options
-     * @returns Array of ragequit events
-     * @throws {DataError} If client is not configured or network error occurs
+     * @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)
+     * @throws {DataError} If client is not configured, network error occurs, or event data is invalid
      */
     async getRagequits(chainId, options = {}) {
         try {
             const client = this.getClientForChain(chainId);
             const config = this.getConfigForChain(chainId);
-            const fromBlock = options.fromBlock ?? config.startBlock;
-            const toBlock = options.toBlock ?? undefined;
-            this.logger.debug(`Fetching ragequits for chain ${chainId} from block ${fromBlock}${toBlock ? ` to ${toBlock}` : ""}`);
-            const query = presetQueryLogsOfEvent(config.privacyPoolAddress, 
-            // topic0 is keccak256("Ragequit(address,uint256,uint256,uint256)")
-            "0xd2b3e868ae101106371f2bd93abc8d5a4de488b9fe47ed122c23625aa7172f13", Number(fromBlock), toBlock ? Number(toBlock) : undefined);
-            const res = await client.get(query);
-            // Create a map of block numbers to timestamps
-            const blockTimestamps = new Map(res.data.blocks.map(block => [
-                block.number,
-                block.timestamp ? BigInt(block.timestamp) : 0n
-            ]));
-            return res.data.logs.map((log) => {
-                if (!log.topics || log.topics.length < 2) {
-                    throw DataError.invalidLog("ragequit", "missing topics");
-                }
-                const ragequitterTopic = log.topics[1];
-                if (!ragequitterTopic) {
-                    throw DataError.invalidLog("ragequit", "missing ragequitter topic");
-                }
-                const ragequitter = BigInt(ragequitterTopic);
-                if (!log.data) {
-                    throw DataError.invalidLog("ragequit", "missing data");
-                }
-                const data = log.data.slice(2).match(/.{64}/g);
-                if (!data || data.length < 3) {
-                    throw DataError.invalidLog("ragequit", "insufficient data");
-                }
-                const commitment = BigInt("0x" + data[0]);
-                const label = BigInt("0x" + data[1]);
-                const value = BigInt("0x" + data[2]);
-                if (!ragequitter ||
-                    !commitment ||
-                    !label ||
-                    !value ||
-                    !log.blockNumber ||
-                    !log.transactionHash) {
-                    throw DataError.invalidLog("ragequit", "missing required fields");
-                }
-                const blockNumber = BigInt(log.blockNumber);
-                const timestamp = blockTimestamps.get(Number(blockNumber));
-                if (!timestamp) {
-                    throw DataError.invalidLog("ragequit", "missing block timestamp");
-                }
-                return {
-                    ragequitter: `0x${ragequitter.toString(16).padStart(40, "0")}`,
-                    commitment: bigintToHash(commitment),
-                    label: bigintToHash(label),
-                    value,
-                    blockNumber,
-                    timestamp,
-                    transactionHash: log.transactionHash,
-                };
+            const logs = await client.getLogs({
+                address: config.privacyPoolAddress,
+                event: RAGEQUIT_EVENT,
+                fromBlock: options.fromBlock ?? config.startBlock,
+                toBlock: options.toBlock,
+            }).catch(error => {
+                throw new DataError("Failed to fetch ragequit logs", ErrorCode.NETWORK_ERROR, { error: error instanceof Error ? error.message : "Unknown error" });
             });
-        }
-        catch (error) {
-            if (error instanceof DataError)
-                throw error;
-            throw DataError.networkError(chainId, error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    /**
-     * Get all events (deposits and withdrawals) for a specific chain in chronological order
-     *
-     * @param chainId - Chain ID to fetch events from
-     * @param options - Event filter options
-     * @returns Array of events sorted by block number
-     * @throws {DataError} If client is not configured or network error occurs
-     */
-    async getAllEvents(chainId, options = {}) {
-        try {
-            const [deposits, withdrawals] = await Promise.all([
-                this.getDeposits(chainId, options),
-                this.getWithdrawals(chainId, options),
-            ]);
-            return [
-                ...deposits.map((d) => ({ type: "deposit", ...d })),
-                ...withdrawals.map((w) => ({ type: "withdrawal", ...w })),
-            ].sort((a, b) => {
-                const blockDiff = a.blockNumber - b.blockNumber;
-                if (blockDiff === 0n) {
-                    return a.type === "deposit" ? -1 : 1;
+            return await Promise.all(logs.map(async (log) => {
+                try {
+                    const block = await client.getBlock({ blockNumber: log.blockNumber });
+                    if (!log.args) {
+                        throw DataError.invalidLog("ragequit", "missing args");
+                    }
+                    const { _ragequitter: ragequitter, _commitment: commitment, _label: label, _value: value, } = log.args;
+                    if (!ragequitter || !commitment || !label || !value || !log.blockNumber || !log.transactionHash) {
+                        throw DataError.invalidLog("ragequit", "missing required fields");
+                    }
+                    return {
+                        ragequitter: ragequitter.toLowerCase(),
+                        commitment: commitment,
+                        label: label,
+                        value,
+                        blockNumber: BigInt(log.blockNumber),
+                        timestamp: BigInt(block.timestamp),
+                        transactionHash: log.transactionHash,
+                    };
                 }
-                return Number(blockDiff);
-            });
+                catch (error) {
+                    if (error instanceof DataError)
+                        throw error;
+                    throw DataError.invalidLog("ragequit", error instanceof Error ? error.message : "Unknown error");
+                }
+            }));
         }
         catch (error) {
             if (error instanceof DataError)
@@ -69280,29 +69182,13 @@ class DataService {
         return client;
     }
     getConfigForChain(chainId) {
-        const config = this.chainConfigs.find((c) => c.chainId === chainId);
+        const config = this.chainConfigs.find(c => c.chainId === chainId);
         if (!config) {
             throw DataError.chainNotConfigured(chainId);
         }
         return config;
     }
-    getHypersyncUrlForChain(chainId) {
-        switch (chainId) {
-            case 1: // Ethereum Mainnet
-                return "https://eth.hypersync.xyz";
-            case 137: // Polygon
-                return "https://polygon.hypersync.xyz";
-            case 42161: // Arbitrum
-                return "https://arbitrum.hypersync.xyz";
-            case 10: // Optimism
-                return "https://optimism.hypersync.xyz";
-            case 11155111: // Sepolia
-                return "https://sepolia.hypersync.xyz";
-            default:
-                throw DataError.chainNotConfigured(chainId);
-        }
-    }
 }
 
 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-BLHTvD4r.js.map
+//# sourceMappingURL=index-CWlKxlGD.js.map