@atomiqlabs/chain-evm 1.0.0-dev.22

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

@@ -0,0 +1,26 @@
+"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;
+        }
+    }
+}
+exports.EVMAddresses = EVMAddresses;

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

@@ -0,0 +1,20 @@
+import { EVMModule } from "../EVMModule";
+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
+     */
+    getBlockTime(blockTag: EVMBlockTag | number): Promise<number>;
+}

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

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

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

@@ -0,0 +1,36 @@
+import { EVMModule } from "../EVMModule";
+import { Log } from "ethers";
+export declare 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
+     */
+    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,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMEvents = void 0;
+const EVMModule_1 = require("../EVMModule");
+class EVMEvents extends EVMModule_1.EVMModule {
+    /**
+     * 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 == 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
+     */
+    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;

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

@@ -0,0 +1,35 @@
+import { Provider, TransactionRequest } from "ethers";
+export type EVMFeeRate = {
+    maxFeePerGas: bigint;
+    maxPriorityFee: bigint;
+};
+export declare class EVMFees {
+    private readonly logger;
+    private readonly provider;
+    private readonly maxFeeRatePerGas;
+    private readonly priorityFee;
+    private readonly feeMultiplierPPM;
+    private blockFeeCache;
+    constructor(provider: Provider, 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: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @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,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMFees = void 0;
+const Utils_1 = require("../../../utils/Utils");
+const MAX_FEE_AGE = 5000;
+class EVMFees {
+    constructor(provider, maxFeeRatePerGas = 500n * 1000000000n, priorityFee = 1n * 1000000000n, feeMultiplier = 1.25) {
+        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: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @private
+     */
+    async getFeeRate() {
+        if (this.blockFeeCache == null || Date.now() - this.blockFeeCache.timestamp > 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);
+        tx.gasLimit = BigInt(gas) + 21000n;
+    }
+}
+exports.EVMFees = EVMFees;

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EVMSigner } from "../../wallet/EVMSigner";
+import { EVMModule } from "../EVMModule";
+import { EVMChainInterface } from "../EVMChainInterface";
+import { TypedDataField } from "ethers";
+export declare class EVMSignatures extends EVMModule<any> {
+    private readonly domainName;
+    constructor(root: EVMChainInterface<any>, domainName?: string);
+    signTypedMessage(contract: string, signer: EVMSigner, type: TypedDataField[], typeName: string, message: object): Promise<string>;
+    isValidSignature(contract: string, signature: string, address: string, type: TypedDataField[], typeName: string, message: object): Promise<boolean>;
+    /**
+     * 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
+     */
+    getDataSignature(signer: EVMSigner, data: Buffer): Promise<string>;
+    /**
+     * 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
+     */
+    isValidDataSignature(data: Buffer, signature: string, address: string): Promise<boolean>;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSignatures = void 0;
+const EVMModule_1 = require("../EVMModule");
+const ethers_1 = require("ethers");
+const DataHash = [
+    { name: "dataHash", type: "bytes32" }
+];
+class EVMSignatures extends EVMModule_1.EVMModule {
+    constructor(root, domainName = "atomiq.exchange") {
+        super(root);
+        this.domainName = domainName;
+    }
+    async signTypedMessage(contract, signer, type, typeName, message) {
+        return signer.account.signTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: contract
+        }, { [typeName]: type }, message);
+    }
+    async isValidSignature(contract, signature, address, type, typeName, message) {
+        return Promise.resolve(address === (0, ethers_1.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
+     */
+    getDataSignature(signer, data) {
+        return signer.account.signTypedData({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000"
+        }, { DataHash }, {
+            dataHash: (0, ethers_1.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
+     */
+    isValidDataSignature(data, signature, address) {
+        return Promise.resolve(address === (0, ethers_1.verifyTypedData)({
+            name: this.domainName,
+            version: "1",
+            chainId: BigInt(this.root.evmChainId),
+            verifyingContract: "0x0000000000000000000000000000000000000000"
+        }, { DataHash }, {
+            dataHash: (0, ethers_1.sha256)(data)
+        }, signature));
+    }
+}
+exports.EVMSignatures = EVMSignatures;

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

@@ -0,0 +1,49 @@
+import { EVMModule } from "../EVMModule";
+import { TransactionRequest } from "ethers";
+export declare class EVMTokens extends EVMModule<any> {
+    static readonly ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+    static readonly GasCosts: {
+        TRANSFER: number;
+        APPROVE: number;
+    };
+    private getContract;
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    isValidToken(token: string): boolean;
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    getTokenBalance(address: string, token: string): Promise<bigint>;
+    /**
+     * Returns the native currency address
+     */
+    getNativeCurrencyAddress(): string;
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    Transfer(signer: string, token: string, amount: bigint, recipient: string, feeRate?: string): Promise<TransactionRequest>;
+    /**
+     * Creates transactions for approving spending of tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param spender recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    Approve(signer: string, token: string, amount: bigint, spender: string, feeRate?: string): Promise<TransactionRequest>;
+}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMTokens = void 0;
+const EVMModule_1 = require("../EVMModule");
+const ethers_1 = require("ethers");
+const ERC20Abi_1 = require("./ERC20Abi");
+const EVMAddresses_1 = require("./EVMAddresses");
+const EVMFees_1 = require("./EVMFees");
+class EVMTokens extends EVMModule_1.EVMModule {
+    getContract(address) {
+        return new ethers_1.Contract(address, ERC20Abi_1.ERC20Abi, this.root.provider);
+    }
+    ///////////////////
+    //// Tokens
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    isValidToken(token) {
+        return EVMAddresses_1.EVMAddresses.isValidAddress(token);
+    }
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    async getTokenBalance(address, token) {
+        let balance;
+        if (token === "0x0000000000000000000000000000000000000000") {
+            balance = await this.provider.getBalance(address);
+        }
+        else {
+            const erc20 = this.getContract(token);
+            balance = await erc20.balanceOf(address);
+        }
+        this.logger.debug("getTokenBalance(): token balance fetched, token: " + token +
+            " address: " + address + " amount: " + balance.toString(10));
+        return balance;
+    }
+    /**
+     * Returns the native currency address
+     */
+    getNativeCurrencyAddress() {
+        return "0x0000000000000000000000000000000000000000";
+    }
+    ///////////////////
+    //// Transfers
+    /**
+     * Creates transactions for sending the over the tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param recipient recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    async Transfer(signer, token, amount, recipient, feeRate) {
+        let tx;
+        if (token === this.getNativeCurrencyAddress()) {
+            tx = {
+                to: recipient,
+                value: amount
+            };
+        }
+        else {
+            tx = await this.getContract(token).transfer.populateTransaction(recipient, amount);
+        }
+        tx.from = signer;
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMTokens.GasCosts.TRANSFER, feeRate ?? await this.root.Fees.getFeeRate());
+        this.logger.debug("txsTransfer(): transfer TX created, recipient: " + recipient.toString() +
+            " token: " + token.toString() + " amount: " + amount.toString(10));
+        return tx;
+    }
+    ///////////////////
+    //// Approval
+    /**
+     * Creates transactions for approving spending of tokens
+     *
+     * @param signer
+     * @param token token to send
+     * @param amount amount of the token to send
+     * @param spender recipient's address
+     * @param feeRate fee rate to use for the transactions
+     * @private
+     */
+    async Approve(signer, token, amount, spender, feeRate) {
+        if (token === this.getNativeCurrencyAddress())
+            return null;
+        const tx = await this.getContract(token).approve.populateTransaction(spender, amount);
+        tx.from = signer;
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMTokens.GasCosts.APPROVE, feeRate ?? await this.root.Fees.getFeeRate());
+        this.logger.debug("txsTransfer(): approve TX created, spender: " + spender.toString() +
+            " token: " + token.toString() + " amount: " + amount.toString(10));
+        return tx;
+    }
+}
+exports.EVMTokens = EVMTokens;
+EVMTokens.ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+EVMTokens.GasCosts = {
+    TRANSFER: 80000,
+    APPROVE: 80000
+};