@atomiqlabs/chain-evm 1.0.0-dev.100

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

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20Abi = void 0;
+exports.ERC20Abi = [
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_spender",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "totalSupply",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_from",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "decimals",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint8"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "name": "balance",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "constant": false,
+        "inputs": [
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_value",
+                "type": "uint256"
+            }
+        ],
+        "name": "transfer",
+        "outputs": [
+            {
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "constant": true,
+        "inputs": [
+            {
+                "name": "_owner",
+                "type": "address"
+            },
+            {
+                "name": "_spender",
+                "type": "address"
+            }
+        ],
+        "name": "allowance",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "payable": false,
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "payable": true,
+        "stateMutability": "payable",
+        "type": "fallback"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "spender",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "value",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    }
+];

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

@@ -0,0 +1,10 @@
+import { EVMModule } from "../EVMModule";
+export declare class EVMAddresses extends EVMModule<any> {
+    /**
+     * Checks whether an address is a valid EVM address
+     *
+     * @param value
+     */
+    static isValidAddress(value: string): boolean;
+    static randomAddress(): string;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMAddresses = void 0;
+const EVMModule_1 = require("../EVMModule");
+const ethers_1 = require("ethers");
+class EVMAddresses extends EVMModule_1.EVMModule {
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid EVM address
+     *
+     * @param value
+     */
+    static isValidAddress(value) {
+        if (value.length !== 42)
+            return false;
+        try {
+            (0, ethers_1.isAddress)(value);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    static randomAddress() {
+        const wallet = ethers_1.Wallet.createRandom();
+        return wallet.address;
+    }
+}
+exports.EVMAddresses = EVMAddresses;

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

@@ -0,0 +1,27 @@
+import { EVMModule } from "../EVMModule";
+import { Block } from "ethers";
+export type EVMBlockTag = "safe" | "pending" | "latest" | "finalized";
+export declare class EVMBlocks extends EVMModule<any> {
+    private BLOCK_CACHE_TIME;
+    private blockCache;
+    /**
+     * Initiates fetch of a given block & saves it to cache
+     *
+     * @private
+     * @param blockTag
+     */
+    private fetchAndSaveBlockTime;
+    private cleanupBlocks;
+    /**
+     * Gets the block for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlock(blockTag: EVMBlockTag | number): Promise<Block>;
+    /**
+     * Gets the block time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    getBlockTime(blockTag: EVMBlockTag | number): Promise<number>;
+}

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

@@ -0,0 +1,73 @@
+"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 blockPromise = this.provider.getBlock(blockTag, false);
+        const timestamp = Date.now();
+        this.blockCache[blockTagStr] = {
+            block: blockPromise,
+            timestamp
+        };
+        blockPromise.catch(e => {
+            if (this.blockCache[blockTagStr] != null && this.blockCache[blockTagStr].block === blockPromise)
+                delete this.blockCache[blockTagStr];
+            throw e;
+        });
+        return {
+            block: blockPromise,
+            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
+     */
+    getBlock(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.block;
+    }
+    /**
+     * Gets the block time for a given blocktag, with caching
+     *
+     * @param blockTag
+     */
+    async getBlockTime(blockTag) {
+        const block = await this.getBlock(blockTag);
+        return block.timestamp;
+    }
+}
+exports.EVMBlocks = EVMBlocks;

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

@@ -0,0 +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>;
+}

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

@@ -0,0 +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);
+        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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMFees = void 0;
+const Utils_1 = require("../../../utils/Utils");
+class EVMFees {
+    constructor(provider, maxFeeRatePerGas = 500n * 1000000000n, priorityFee = 1n * 1000000000n, feeMultiplier = 1.25) {
+        this.MAX_FEE_AGE = 5000;
+        this.logger = (0, Utils_1.getLogger)("EVMFees: ");
+        this.blockFeeCache = null;
+        this.provider = provider;
+        this.maxFeeRatePerGas = maxFeeRatePerGas;
+        this.priorityFee = priorityFee;
+        this.feeMultiplierPPM = BigInt(Math.floor(feeMultiplier * 1000000));
+    }
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    async _getFeeRate() {
+        const block = await this.provider.getBlock("latest");
+        const baseFee = block.baseFeePerGas * this.feeMultiplierPPM / 1000000n;
+        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
+     */
+    async getFeeRate() {
+        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
+     */
+    static getGasFee(gas, feeRate) {
+        if (feeRate == null)
+            return 0n;
+        const [baseFee, priorityFee] = feeRate.split(",");
+        return BigInt(gas) * (BigInt(baseFee) + BigInt(priorityFee));
+    }
+    static applyFeeRate(tx, gas, feeRate) {
+        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);
+    }
+}
+exports.EVMFees = EVMFees;