@atomiqlabs/chain-evm 1.0.0-dev.89 → 1.0.0-dev.93

package/dist/evm/chain/modules/EVMBlocks.js

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMBlocks = void 0;
-const EVMModule_1 = require("../EVMModule");
-class EVMBlocks extends EVMModule_1.EVMModule {
-    constructor() {
-        super(...arguments);
-        this.BLOCK_CACHE_TIME = 5 * 1000;
-        this.blockCache = {};
-    }
-    /**
-     * Initiates fetch of a given block & saves it to cache
-     *
-     * @private
-     * @param blockTag
-     */
-    fetchAndSaveBlockTime(blockTag) {
-        const blockTagStr = blockTag.toString(10);
-        const blockTimePromise = this.provider.getBlock(blockTag, false).then(result => result.timestamp);
-        const timestamp = Date.now();
-        this.blockCache[blockTagStr] = {
-            blockTime: blockTimePromise,
-            timestamp
-        };
-        blockTimePromise.catch(e => {
-            if (this.blockCache[blockTagStr] != null && this.blockCache[blockTagStr].blockTime === blockTimePromise)
-                delete this.blockCache[blockTagStr];
-            throw e;
-        });
-        return {
-            blockTime: blockTimePromise,
-            timestamp
-        };
-    }
-    cleanupBlocks() {
-        const currentTime = Date.now();
-        //Keys are in order that they were added, so we can stop at the first non-expired block
-        for (let key in this.blockCache) {
-            const block = this.blockCache[key];
-            if (currentTime - block.timestamp > this.BLOCK_CACHE_TIME) {
-                delete this.blockCache[key];
-            }
-            else {
-                break;
-            }
-        }
-    }
-    ///////////////////
-    //// Blocks
-    /**
-     * Gets the block for a given blocktag, with caching
-     *
-     * @param blockTag
-     */
-    getBlockTime(blockTag) {
-        this.cleanupBlocks();
-        let cachedBlockData = this.blockCache[blockTag.toString(10)];
-        if (cachedBlockData == null || Date.now() - cachedBlockData.timestamp > this.BLOCK_CACHE_TIME) {
-            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
-        }
-        return cachedBlockData.blockTime;
-    }
-}
-exports.EVMBlocks = EVMBlocks;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMBlocks = void 0;
+const EVMModule_1 = require("../EVMModule");
+class EVMBlocks extends EVMModule_1.EVMModule {
+    constructor() {
+        super(...arguments);
+        this.BLOCK_CACHE_TIME = 5 * 1000;
+        this.blockCache = {};
+    }
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    fetchAndSaveBlockTime(blockTag) {
+        const blockTagStr = blockTag.toString(10);
+        const blockTimePromise = this.provider.getBlock(blockTag, false).then(result => result.timestamp);
+        const timestamp = Date.now();
+        this.blockCache[blockTagStr] = {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+        blockTimePromise.catch(e => {
+            if (this.blockCache[blockTagStr] != null && this.blockCache[blockTagStr].blockTime === blockTimePromise)
+                delete this.blockCache[blockTagStr];
+            throw e;
+        });
+        return {
+            blockTime: blockTimePromise,
+            timestamp
+        };
+    }
+    cleanupBlocks() {
+        const currentTime = Date.now();
+        //Keys are in order that they were added, so we can stop at the first non-expired block
+        for (let key in this.blockCache) {
+            const block = this.blockCache[key];
+            if (currentTime - block.timestamp > this.BLOCK_CACHE_TIME) {
+                delete this.blockCache[key];
+            }
+            else {
+                break;
+            }
+        }
+    }
+    ///////////////////
+    //// Blocks
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlockTime(blockTag) {
+        this.cleanupBlocks();
+        let cachedBlockData = this.blockCache[blockTag.toString(10)];
+        if (cachedBlockData == null || Date.now() - cachedBlockData.timestamp > this.BLOCK_CACHE_TIME) {
+            cachedBlockData = this.fetchAndSaveBlockTime(blockTag);
+        }
+        return cachedBlockData.blockTime;
+    }
+}
+exports.EVMBlocks = EVMBlocks;

package/dist/evm/chain/modules/EVMEvents.d.ts

@@ -1,46 +1,46 @@
-import { EVMModule } from "../EVMModule";
-import { Log } from "ethers";
-export declare class EVMEvents extends EVMModule<any> {
-    /**
-     * Wrapper for provider.getLogs(), automatically retries with smaller ranges if limits are reached
-     *
-     * @param contract
-     * @param topics
-     * @param startBlock
-     * @param endBlock
-     * @private
-     */
-    private getLogs;
-    /**
-     * Returns the all the events occuring in a block range as identified by the contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param startBlock
-     * @param endBlock
-     * @param abortSignal
-     */
-    getBlockEvents(contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock?: number, abortSignal?: AbortSignal): Promise<Log[]>;
-    /**
-     * Runs a search backwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param genesisHeight Height when the contract was deployed
-     */
-    findInEvents<T>(contract: string, topics: (string[] | string | null)[], processor: (signatures: Log[]) => Promise<T>, abortSignal?: AbortSignal, genesisHeight?: number): Promise<T>;
-    /**
-     * Runs a search forwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param startHeight Blockheight at which to start
-     */
-    findInEventsForward<T>(contract: string, topics: (string[] | string | null)[], processor: (signatures: Log[]) => Promise<T>, abortSignal?: AbortSignal, startHeight?: number): Promise<T>;
-}
+import { EVMModule } from "../EVMModule";
+import { Log } from "ethers";
+export declare class EVMEvents extends EVMModule<any> {
+    /**
+     * Wrapper for provider.getLogs(), automatically retries with smaller ranges if limits are reached
+     *
+     * @param contract
+     * @param topics
+     * @param startBlock
+     * @param endBlock
+     * @private
+     */
+    private getLogs;
+    /**
+     * Returns the all the events occuring in a block range as identified by the contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param startBlock
+     * @param endBlock
+     * @param abortSignal
+     */
+    getBlockEvents(contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock?: number, abortSignal?: AbortSignal): Promise<Log[]>;
+    /**
+     * Runs a search backwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param genesisHeight Height when the contract was deployed
+     */
+    findInEvents<T>(contract: string, topics: (string[] | string | null)[], processor: (signatures: Log[]) => Promise<T>, abortSignal?: AbortSignal, genesisHeight?: number): Promise<T>;
+    /**
+     * Runs a search forwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param startHeight Blockheight at which to start
+     */
+    findInEventsForward<T>(contract: string, topics: (string[] | string | null)[], processor: (signatures: Log[]) => Promise<T>, abortSignal?: AbortSignal, startHeight?: number): Promise<T>;
+}

package/dist/evm/chain/modules/EVMEvents.js

@@ -1,137 +1,151 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMEvents = void 0;
-const EVMModule_1 = require("../EVMModule");
-class EVMEvents extends EVMModule_1.EVMModule {
-    /**
-     * Wrapper for provider.getLogs(), automatically retries with smaller ranges if limits are reached
-     *
-     * @param contract
-     * @param topics
-     * @param startBlock
-     * @param endBlock
-     * @private
-     */
-    async getLogs(contract, topics, startBlock, endBlock) {
-        try {
-            return await this.root.provider.getLogs({
-                address: contract,
-                fromBlock: startBlock,
-                toBlock: endBlock,
-                topics
-            });
-        }
-        catch (e) {
-            if (e.error?.code === -32008 || //Response is too big
-                e.error?.code === -32005 //Limit exceeded
-            ) {
-                if (startBlock === endBlock)
-                    throw e;
-                const difference = (endBlock - startBlock) / 2;
-                const midpoint = startBlock + Math.floor(difference);
-                this.logger.warn(`getLogs(): Error getting logs, limits reached, splitting to 2 ranges: ${startBlock}..${midpoint} & ${midpoint + 1}..${endBlock}: `, e);
-                return [
-                    ...await this.getLogs(contract, topics, startBlock, midpoint),
-                    ...await this.getLogs(contract, topics, midpoint + 1, endBlock),
-                ];
-            }
-            throw e;
-        }
-    }
-    /**
-     * Returns the all the events occuring in a block range as identified by the contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param startBlock
-     * @param endBlock
-     * @param abortSignal
-     */
-    async getBlockEvents(contract, topics, startBlock, endBlock = startBlock, abortSignal) {
-        let events = [];
-        if (startBlock === endBlock) {
-            events = await this.root.provider.getLogs({
-                address: contract,
-                fromBlock: startBlock,
-                toBlock: endBlock == null ? this.root.config.safeBlockTag : endBlock,
-                topics
-            });
-        }
-        else if (endBlock == null) {
-            const safeBlock = await this.root.provider.getBlock(this.root.config.safeBlockTag);
-            if (safeBlock.number - startBlock > this.root.config.maxLogsBlockRange) {
-                for (let i = startBlock + this.root.config.maxLogsBlockRange; i < safeBlock.number; i += this.root.config.maxLogsBlockRange) {
-                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
-                    startBlock = i;
-                }
-            }
-            events.push(...await this.getLogs(contract, topics, startBlock, safeBlock.number));
-        }
-        else {
-            //Both numeric
-            if (endBlock - startBlock > this.root.config.maxLogsBlockRange) {
-                for (let i = startBlock + this.root.config.maxLogsBlockRange; i < endBlock; i += this.root.config.maxLogsBlockRange) {
-                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
-                    startBlock = i;
-                }
-            }
-            events.push(...await this.getLogs(contract, topics, startBlock, endBlock));
-        }
-        return events.filter(val => !val.removed);
-    }
-    /**
-     * Runs a search backwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param genesisHeight Height when the contract was deployed
-     */
-    async findInEvents(contract, topics, processor, abortSignal, genesisHeight) {
-        const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
-        for (let blockNumber = latestBlockNumber; blockNumber >= (genesisHeight ?? 0); blockNumber -= this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
-                topics,
-                fromBlock: Math.max(blockNumber - this.root.config.maxLogsBlockRange, 0),
-                toBlock: blockNumber === latestBlockNumber ? this.root.config.safeBlockTag : blockNumber
-            });
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            const result = await processor(eventsResult.reverse()); //Newest events first
-            if (result != null)
-                return result;
-        }
-        return null;
-    }
-    /**
-     * Runs a search forwards in time, processing events from a specific contract and keys
-     *
-     * @param contract
-     * @param topics
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param startHeight Blockheight at which to start
-     */
-    async findInEventsForward(contract, topics, processor, abortSignal, startHeight) {
-        const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
-        for (let blockNumber = startHeight ?? 0; blockNumber < latestBlockNumber; blockNumber += this.root.config.maxLogsBlockRange) {
-            const eventsResult = await this.provider.getLogs({
-                address: contract,
-                topics,
-                fromBlock: blockNumber,
-                toBlock: (blockNumber + this.root.config.maxLogsBlockRange) > latestBlockNumber ? this.root.config.safeBlockTag : blockNumber + this.root.config.maxLogsBlockRange
-            });
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            const result = await processor(eventsResult); //Oldest events first
-            if (result != null)
-                return result;
-        }
-        return null;
-    }
-}
-exports.EVMEvents = EVMEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMEvents = void 0;
+const EVMModule_1 = require("../EVMModule");
+class EVMEvents extends EVMModule_1.EVMModule {
+    /**
+     * Wrapper for provider.getLogs(), automatically retries with smaller ranges if limits are reached
+     *
+     * @param contract
+     * @param topics
+     * @param startBlock
+     * @param endBlock
+     * @private
+     */
+    async getLogs(contract, topics, startBlock, endBlock) {
+        try {
+            return await this.root.provider.getLogs({
+                address: contract,
+                fromBlock: startBlock,
+                toBlock: endBlock,
+                topics
+            });
+        }
+        catch (e) {
+            if (e.error?.code === -32008 || //Response is too big
+                e.error?.code === -32005 //Limit exceeded
+            ) {
+                if (startBlock === endBlock)
+                    throw e;
+                const difference = (endBlock - startBlock) / 2;
+                const midpoint = startBlock + Math.floor(difference);
+                this.logger.warn(`getLogs(): Error getting logs, limits reached, splitting to 2 ranges: ${startBlock}..${midpoint} & ${midpoint + 1}..${endBlock}: `, e);
+                return [
+                    ...await this.getLogs(contract, topics, startBlock, midpoint),
+                    ...await this.getLogs(contract, topics, midpoint + 1, endBlock),
+                ];
+            }
+            throw e;
+        }
+    }
+    /**
+     * Returns the all the events occuring in a block range as identified by the contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param startBlock
+     * @param endBlock
+     * @param abortSignal
+     */
+    async getBlockEvents(contract, topics, startBlock, endBlock = startBlock, abortSignal) {
+        let events = [];
+        if (startBlock === endBlock) {
+            events = await this.root.provider.getLogs({
+                address: contract,
+                fromBlock: startBlock,
+                toBlock: endBlock == null ? this.root.config.safeBlockTag : endBlock,
+                topics
+            });
+        }
+        else if (endBlock == null) {
+            const safeBlock = await this.root.provider.getBlock(this.root.config.safeBlockTag);
+            if (safeBlock.number - startBlock > this.root.config.maxLogsBlockRange) {
+                for (let i = startBlock + this.root.config.maxLogsBlockRange; i < safeBlock.number; i += this.root.config.maxLogsBlockRange) {
+                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
+                    startBlock = i;
+                }
+            }
+            events.push(...await this.getLogs(contract, topics, startBlock, safeBlock.number));
+        }
+        else {
+            //Both numeric
+            if (endBlock - startBlock > this.root.config.maxLogsBlockRange) {
+                for (let i = startBlock + this.root.config.maxLogsBlockRange; i < endBlock; i += this.root.config.maxLogsBlockRange) {
+                    events.push(...await this.getLogs(contract, topics, i - this.root.config.maxLogsBlockRange, i));
+                    startBlock = i;
+                }
+            }
+            events.push(...await this.getLogs(contract, topics, startBlock, endBlock));
+        }
+        return events.filter(val => !val.removed);
+    }
+    /**
+     * Runs a search backwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param genesisHeight Height when the contract was deployed
+     */
+    async findInEvents(contract, topics, processor, abortSignal, genesisHeight) {
+        const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
+        let promises = [];
+        for (let blockNumber = latestBlockNumber; blockNumber >= (genesisHeight ?? 0); blockNumber -= this.root.config.maxLogsBlockRange) {
+            promises.push(this.getLogs(contract, topics, Math.max(blockNumber - this.root.config.maxLogsBlockRange, 0), blockNumber));
+            if (promises.length >= this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).map(arr => arr.reverse() //Oldest events first
+                ).flat();
+                promises = [];
+                if (abortSignal != null)
+                    abortSignal.throwIfAborted();
+                const result = await processor(eventsResult);
+                if (result != null)
+                    return result;
+            }
+        }
+        const eventsResult = (await Promise.all(promises)).map(arr => arr.reverse() //Oldest events first
+        ).flat();
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        const result = await processor(eventsResult); //Oldest events first
+        if (result != null)
+            return result;
+        return null;
+    }
+    /**
+     * Runs a search forwards in time, processing events from a specific contract and keys
+     *
+     * @param contract
+     * @param topics
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param startHeight Blockheight at which to start
+     */
+    async findInEventsForward(contract, topics, processor, abortSignal, startHeight) {
+        const { number: latestBlockNumber } = await this.provider.getBlock(this.root.config.safeBlockTag);
+        let promises = [];
+        for (let blockNumber = startHeight ?? 0; blockNumber < latestBlockNumber; blockNumber += this.root.config.maxLogsBlockRange) {
+            promises.push(this.getLogs(contract, topics, blockNumber, Math.min(blockNumber + this.root.config.maxLogsBlockRange, latestBlockNumber)));
+            if (promises.length >= this.root.config.maxParallelLogRequests) {
+                const eventsResult = (await Promise.all(promises)).flat();
+                promises = [];
+                if (abortSignal != null)
+                    abortSignal.throwIfAborted();
+                const result = await processor(eventsResult); //Oldest events first
+                if (result != null)
+                    return result;
+            }
+        }
+        const eventsResult = (await Promise.all(promises)).flat();
+        if (abortSignal != null)
+            abortSignal.throwIfAborted();
+        const result = await processor(eventsResult); //Oldest events first
+        if (result != null)
+            return result;
+        return null;
+    }
+}
+exports.EVMEvents = EVMEvents;

package/dist/evm/chain/modules/EVMFees.d.ts

@@ -1,36 +1,36 @@
-import { JsonRpcApiProvider, TransactionRequest } from "ethers";
-export type EVMFeeRate = {
-    maxFeePerGas: bigint;
-    maxPriorityFee: bigint;
-};
-export declare class EVMFees {
-    protected MAX_FEE_AGE: number;
-    protected readonly logger: import("../../../utils/Utils").LoggerType;
-    protected readonly provider: JsonRpcApiProvider;
-    protected readonly maxFeeRatePerGas: bigint;
-    protected readonly priorityFee: bigint;
-    protected readonly feeMultiplierPPM: bigint;
-    private blockFeeCache;
-    constructor(provider: JsonRpcApiProvider, maxFeeRatePerGas?: bigint, priorityFee?: bigint, feeMultiplier?: number);
-    /**
-     * Gets evm fee rate
-     *
-     * @private
-     * @returns {Promise<bigint>} L1 gas price denominated in Wei
-     */
-    private _getFeeRate;
-    /**
-     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
-     *
-     * @private
-     */
-    getFeeRate(): Promise<string>;
-    /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
-     *
-     * @param gas
-     * @param feeRate
-     */
-    static getGasFee(gas: number, feeRate: string): bigint;
-    static applyFeeRate(tx: TransactionRequest, gas: number, feeRate: string): any;
-}
+import { JsonRpcApiProvider, TransactionRequest } from "ethers";
+export type EVMFeeRate = {
+    maxFeePerGas: bigint;
+    maxPriorityFee: bigint;
+};
+export declare class EVMFees {
+    protected MAX_FEE_AGE: number;
+    protected readonly logger: import("../../../utils/Utils").LoggerType;
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly maxFeeRatePerGas: bigint;
+    protected readonly priorityFee: bigint;
+    protected readonly feeMultiplierPPM: bigint;
+    private blockFeeCache;
+    constructor(provider: JsonRpcApiProvider, maxFeeRatePerGas?: bigint, priorityFee?: bigint, feeMultiplier?: number);
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    private _getFeeRate;
+    /**
+     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
+     *
+     * @private
+     */
+    getFeeRate(): Promise<string>;
+    /**
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    static getGasFee(gas: number, feeRate: string): bigint;
+    static applyFeeRate(tx: TransactionRequest, gas: number, feeRate: string): any;
+}