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

package/src/evm/chain/modules/EVMEvents.ts

@@ -1,182 +1,182 @@
-import {EVMModule} from "../EVMModule";
-import {Log} from "ethers";
-
-export 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 async getLogs(
-        contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock: number
-    ): Promise<Log[]> {
-        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
-     */
-    public async getBlockEvents(
-        contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock: number = startBlock, abortSignal?: AbortSignal
-    ): Promise<Log[]> {
-        let events: Log[] = [];
-
-        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
-     */
-    public async findInEvents<T>(
-        contract: string, topics: (string[] | string | null)[],
-        processor: (signatures: Log[]) => Promise<T>,
-        abortSignal?: AbortSignal,
-        genesisHeight?: number
-    ): Promise<T> {
-        const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
-
-        let promises: Promise<Log[]>[] = [];
-        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: T = 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: T = 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
-     */
-    public async findInEventsForward<T>(
-        contract: string, topics: (string[] | string | null)[],
-        processor: (signatures: Log[]) => Promise<T>,
-        abortSignal?: AbortSignal,
-        startHeight?: number
-    ): Promise<T> {
-        const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
-
-        let promises: Promise<Log[]>[] = [];
-        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: T = 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: T = await processor(eventsResult); //Oldest events first
-        if(result!=null) return result;
-
-        return null;
-    }
-
-}
+import {EVMModule} from "../EVMModule";
+import {Log} from "ethers";
+
+export 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 async getLogs(
+        contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock: number
+    ): Promise<Log[]> {
+        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
+     */
+    public async getBlockEvents(
+        contract: string, topics: (string[] | string | null)[], startBlock: number, endBlock: number = startBlock, abortSignal?: AbortSignal
+    ): Promise<Log[]> {
+        let events: Log[] = [];
+
+        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
+     */
+    public async findInEvents<T>(
+        contract: string, topics: (string[] | string | null)[],
+        processor: (signatures: Log[]) => Promise<T>,
+        abortSignal?: AbortSignal,
+        genesisHeight?: number
+    ): Promise<T> {
+        const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
+
+        let promises: Promise<Log[]>[] = [];
+        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: T = 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: T = 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
+     */
+    public async findInEventsForward<T>(
+        contract: string, topics: (string[] | string | null)[],
+        processor: (signatures: Log[]) => Promise<T>,
+        abortSignal?: AbortSignal,
+        startHeight?: number
+    ): Promise<T> {
+        const {number: latestBlockNumber} = await this.provider.getBlock(this.root.config.safeBlockTag);
+
+        let promises: Promise<Log[]>[] = [];
+        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: T = 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: T = await processor(eventsResult); //Oldest events first
+        if(result!=null) return result;
+
+        return null;
+    }
+
+}

package/src/evm/chain/modules/EVMFees.ts

@@ -1,104 +1,104 @@
-import { getLogger } from "../../../utils/Utils";
-import {JsonRpcApiProvider, TransactionRequest} from "ethers";
-
-export type EVMFeeRate = {
-    maxFeePerGas: bigint;
-    maxPriorityFee: bigint;
-};
-
-export class EVMFees {
-    protected MAX_FEE_AGE = 5000;
-
-    protected readonly logger = getLogger("EVMFees: ");
-
-    protected readonly provider: JsonRpcApiProvider;
-    protected readonly maxFeeRatePerGas: bigint;
-    protected readonly priorityFee: bigint;
-
-    protected readonly feeMultiplierPPM: bigint;
-
-    private blockFeeCache: {
-        timestamp: number,
-        feeRate: Promise<bigint>
-    } = null;
-
-    constructor(
-        provider: JsonRpcApiProvider,
-        maxFeeRatePerGas: bigint = 500n * 1_000_000_000n,
-        priorityFee: bigint = 1n * 1_000_000_000n,
-        feeMultiplier: number = 1.25,
-    ) {
-        this.provider = provider;
-        this.maxFeeRatePerGas = maxFeeRatePerGas;
-        this.priorityFee = priorityFee;
-        this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1_000_000));
-    }
-
-    /**
-     * Gets evm fee rate
-     *
-     * @private
-     * @returns {Promise<bigint>} L1 gas price denominated in Wei
-     */
-    private async _getFeeRate(): Promise<bigint> {
-        const block = await this.provider.getBlock("latest");
-
-        const baseFee = block.baseFeePerGas * this.feeMultiplierPPM / 1_000_000n;
-        this.logger.debug("_getFeeRate(): Base fee rate: "+baseFee.toString(10));
-
-        return baseFee;
-    }
-
-    /**
-     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
-     *
-     * @private
-     */
-    public async getFeeRate(): Promise<string> {
-        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > this.MAX_FEE_AGE) {
-            let obj = {
-                timestamp: Date.now(),
-                feeRate: null
-            };
-            obj.feeRate = this._getFeeRate().catch(e => {
-                if(this.blockFeeCache===obj) this.blockFeeCache=null;
-                throw e;
-            });
-            this.blockFeeCache = obj;
-        }
-
-        let baseFee = await this.blockFeeCache.feeRate;
-        if(baseFee>this.maxFeeRatePerGas) baseFee = this.maxFeeRatePerGas;
-
-        const fee = baseFee.toString(10)+","+this.priorityFee.toString(10);
-
-        this.logger.debug("getFeeRate(): calculated fee: "+fee);
-
-        return fee;
-    }
-
-    /**
-     * Calculates the total gas fee paid for a given gas limit at a given fee rate
-     *
-     * @param gas
-     * @param feeRate
-     */
-    public static getGasFee(gas: number, feeRate: string): bigint {
-        if(feeRate==null) return 0n;
-
-        const [baseFee, priorityFee] = feeRate.split(",");
-
-        return BigInt(gas) * (BigInt(baseFee) + BigInt(priorityFee));
-    }
-
-    public static applyFeeRate(tx: TransactionRequest, gas: number, feeRate: string) {
-        if(feeRate==null) return null;
-
-        const [baseFee, priorityFee] = feeRate.split(",");
-
-        tx.maxFeePerGas = BigInt(baseFee) + BigInt(priorityFee);
-        tx.maxPriorityFeePerGas = BigInt(priorityFee);
-        if(gas!=null) tx.gasLimit = BigInt(gas);
-    }
-
-}
+import { getLogger } from "../../../utils/Utils";
+import {JsonRpcApiProvider, TransactionRequest} from "ethers";
+
+export type EVMFeeRate = {
+    maxFeePerGas: bigint;
+    maxPriorityFee: bigint;
+};
+
+export class EVMFees {
+    protected MAX_FEE_AGE = 5000;
+
+    protected readonly logger = getLogger("EVMFees: ");
+
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly maxFeeRatePerGas: bigint;
+    protected readonly priorityFee: bigint;
+
+    protected readonly feeMultiplierPPM: bigint;
+
+    private blockFeeCache: {
+        timestamp: number,
+        feeRate: Promise<bigint>
+    } = null;
+
+    constructor(
+        provider: JsonRpcApiProvider,
+        maxFeeRatePerGas: bigint = 500n * 1_000_000_000n,
+        priorityFee: bigint = 1n * 1_000_000_000n,
+        feeMultiplier: number = 1.25,
+    ) {
+        this.provider = provider;
+        this.maxFeeRatePerGas = maxFeeRatePerGas;
+        this.priorityFee = priorityFee;
+        this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1_000_000));
+    }
+
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    private async _getFeeRate(): Promise<bigint> {
+        const block = await this.provider.getBlock("latest");
+
+        const baseFee = block.baseFeePerGas * this.feeMultiplierPPM / 1_000_000n;
+        this.logger.debug("_getFeeRate(): Base fee rate: "+baseFee.toString(10));
+
+        return baseFee;
+    }
+
+    /**
+     * Gets the gas price with caching, format: <base fee Wei>,<priority fee Wei>
+     *
+     * @private
+     */
+    public async getFeeRate(): Promise<string> {
+        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > this.MAX_FEE_AGE) {
+            let obj = {
+                timestamp: Date.now(),
+                feeRate: null
+            };
+            obj.feeRate = this._getFeeRate().catch(e => {
+                if(this.blockFeeCache===obj) this.blockFeeCache=null;
+                throw e;
+            });
+            this.blockFeeCache = obj;
+        }
+
+        let baseFee = await this.blockFeeCache.feeRate;
+        if(baseFee>this.maxFeeRatePerGas) baseFee = this.maxFeeRatePerGas;
+
+        const fee = baseFee.toString(10)+","+this.priorityFee.toString(10);
+
+        this.logger.debug("getFeeRate(): calculated fee: "+fee);
+
+        return fee;
+    }
+
+    /**
+     * Calculates the total gas fee paid for a given gas limit at a given fee rate
+     *
+     * @param gas
+     * @param feeRate
+     */
+    public static getGasFee(gas: number, feeRate: string): bigint {
+        if(feeRate==null) return 0n;
+
+        const [baseFee, priorityFee] = feeRate.split(",");
+
+        return BigInt(gas) * (BigInt(baseFee) + BigInt(priorityFee));
+    }
+
+    public static applyFeeRate(tx: TransactionRequest, gas: number, feeRate: string) {
+        if(feeRate==null) return null;
+
+        const [baseFee, priorityFee] = feeRate.split(",");
+
+        tx.maxFeePerGas = BigInt(baseFee) + BigInt(priorityFee);
+        tx.maxPriorityFeePerGas = BigInt(priorityFee);
+        if(gas!=null) tx.gasLimit = BigInt(gas);
+    }
+
+}