@atomiqlabs/chain-evm 1.0.0-dev.62 → 1.0.0-dev.64

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

@@ -1,139 +1,139 @@
-import {EVMModule} from "../EVMModule";
-import {Log} from "ethers";
-
-export class EVMEvents extends EVMModule<any> {
-
-    /**
-     * 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==null ? this.root.config.safeBlockTag : 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.root.provider.getLogs({
-                        address: contract,
-                        fromBlock: i - this.root.config.maxLogsBlockRange,
-                        toBlock: i,
-                        topics
-                    }));
-                    startBlock = i;
-                }
-            }
-            events.push(...await this.root.provider.getLogs({
-                address: contract,
-                fromBlock: startBlock==null ? this.root.config.safeBlockTag : startBlock,
-                toBlock: endBlock==null ? this.root.config.safeBlockTag : endBlock,
-                topics
-            }));
-        } 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.root.provider.getLogs({
-                        address: contract,
-                        fromBlock: i - this.root.config.maxLogsBlockRange,
-                        toBlock: i,
-                        topics
-                    }));
-                    startBlock = i;
-                }
-            }
-            events.push(...await this.root.provider.getLogs({
-                address: contract,
-                fromBlock: startBlock,
-                toBlock: endBlock,
-                topics
-            }));
-        }
-
-        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);
-
-        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: T = 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
-     */
-    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);
-
-        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: 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> {
+
+    /**
+     * 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==null ? this.root.config.safeBlockTag : 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.root.provider.getLogs({
+                        address: contract,
+                        fromBlock: i - this.root.config.maxLogsBlockRange,
+                        toBlock: i,
+                        topics
+                    }));
+                    startBlock = i;
+                }
+            }
+            events.push(...await this.root.provider.getLogs({
+                address: contract,
+                fromBlock: startBlock==null ? this.root.config.safeBlockTag : startBlock,
+                toBlock: endBlock==null ? this.root.config.safeBlockTag : endBlock,
+                topics
+            }));
+        } 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.root.provider.getLogs({
+                        address: contract,
+                        fromBlock: i - this.root.config.maxLogsBlockRange,
+                        toBlock: i,
+                        topics
+                    }));
+                    startBlock = i;
+                }
+            }
+            events.push(...await this.root.provider.getLogs({
+                address: contract,
+                fromBlock: startBlock,
+                toBlock: endBlock,
+                topics
+            }));
+        }
+
+        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);
+
+        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: T = 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
+     */
+    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);
+
+        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: 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: <gas price in Wei>;<transaction version: v1/v3>
-     *
-     * @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);
-        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: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @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);
+        tx.gasLimit = BigInt(gas);
+    }
+
+}

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

@@ -1,76 +1,76 @@
-import {EVMSigner} from "../../wallet/EVMSigner";
-import {EVMModule} from "../EVMModule";
-import {EVMChainInterface} from "../EVMChainInterface";
-import {sha256, verifyTypedData, TypedDataField} from "ethers";
-
-const DataHash = [
-    { name: "dataHash", type: "bytes32" }
-];
-
-export class EVMSignatures extends EVMModule<any> {
-
-    private readonly domainName: string;
-
-    constructor(root: EVMChainInterface<any>, domainName: string = "atomiq.exchange") {
-        super(root);
-        this.domainName = domainName;
-    }
-
-    public async signTypedMessage(contract: string, signer: EVMSigner, type: TypedDataField[], typeName: string, message: object): Promise<string> {
-        return signer.account.signTypedData({
-            name: this.domainName,
-            version: "1",
-            chainId: BigInt(this.root.evmChainId),
-            verifyingContract: contract
-        }, {[typeName]: type}, message);
-    }
-
-    public async isValidSignature(contract: string, signature: string, address: string, type: TypedDataField[], typeName: string, message: object): Promise<boolean> {
-        return Promise.resolve(address === verifyTypedData({
-            name: this.domainName,
-            version: "1",
-            chainId: BigInt(this.root.evmChainId),
-            verifyingContract: contract
-        }, {[typeName]: type}, message, signature));
-    }
-
-    ///////////////////
-    //// Data signatures
-    /**
-     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
-     *  expose their private key (i.e. backend based, not browser wallet based)
-     *
-     * @param signer
-     * @param data data to sign
-     */
-    public getDataSignature(signer: EVMSigner, data: Buffer): Promise<string> {
-        return signer.account.signTypedData({
-            name: this.domainName,
-            version: "1",
-            chainId: BigInt(this.root.evmChainId),
-            verifyingContract: "0x0000000000000000000000000000000000000000"
-        }, {DataHash}, {
-            dataHash: sha256(data)
-        });
-    }
-
-    /**
-     * Checks whether a signature is a valid signature produced by the account over a data message (computes
-     *  sha256 hash of the message)
-     *
-     * @param data signed data
-     * @param signature data signature
-     * @param address public key of the signer
-     */
-    public isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean> {
-        return Promise.resolve(address === verifyTypedData({
-            name: this.domainName,
-            version: "1",
-            chainId: BigInt(this.root.evmChainId),
-            verifyingContract: "0x0000000000000000000000000000000000000000"
-        }, {DataHash}, {
-            dataHash: sha256(data)
-        }, signature));
-    }
-
-}
+import {EVMSigner} from "../../wallet/EVMSigner";
+import {EVMModule} from "../EVMModule";
+import {EVMChainInterface} from "../EVMChainInterface";
+import {sha256, verifyTypedData, TypedDataField} from "ethers";
+
+const DataHash = [
+    { name: "dataHash", type: "bytes32" }
+];
+
+export class EVMSignatures extends EVMModule<any> {
+
+    private readonly domainName: string;
+
+    constructor(root: EVMChainInterface<any>, domainName: string = "atomiq.exchange") {
+        super(root);
+        this.domainName = domainName;
+    }
+
+    public async signTypedMessage(contract: string, signer: EVMSigner, type: TypedDataField[], typeName: string, message: object): Promise<string> {
+        return signer.account.signTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: contract
+        }, {[typeName]: type}, message);
+    }
+
+    public async isValidSignature(contract: string, signature: string, address: string, type: TypedDataField[], typeName: string, message: object): Promise<boolean> {
+        return Promise.resolve(address === verifyTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: contract
+        }, {[typeName]: type}, message, signature));
+    }
+
+    ///////////////////
+    //// Data signatures
+    /**
+     * Produces a signature over the sha256 of a specified data Buffer, only works with providers which
+     *  expose their private key (i.e. backend based, not browser wallet based)
+     *
+     * @param signer
+     * @param data data to sign
+     */
+    public getDataSignature(signer: EVMSigner, data: Buffer): Promise<string> {
+        return signer.account.signTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000"
+        }, {DataHash}, {
+            dataHash: sha256(data)
+        });
+    }
+
+    /**
+     * Checks whether a signature is a valid signature produced by the account over a data message (computes
+     *  sha256 hash of the message)
+     *
+     * @param data signed data
+     * @param signature data signature
+     * @param address public key of the signer
+     */
+    public isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean> {
+        return Promise.resolve(address === verifyTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000"
+        }, {DataHash}, {
+            dataHash: sha256(data)
+        }, signature));
+    }
+
+}