@atomiqlabs/chain-evm 1.0.0-dev.37 → 1.0.0-dev.39

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

@@ -1,73 +1,73 @@
-"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: <gas price in Wei>;<transaction version: v1/v3>
-     *
-     * @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);
-        tx.gasLimit = BigInt(gas);
-    }
-}
-exports.EVMFees = EVMFees;
+"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: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @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);
+        tx.gasLimit = BigInt(gas);
+    }
+}
+exports.EVMFees = EVMFees;

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

@@ -1,29 +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>;
-}
+/// <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

@@ -1,68 +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;
+"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

@@ -1,70 +1,70 @@
-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 authorized allowance of specific address towards a spender contract
-     *
-     * @param spender A contract trying to spend user's erc20 balance
-     * @param address Wallet address
-     * @param token ERC-20 token
-     */
-    getTokenAllowance(spender: string, 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>;
-    /**
-     * Checks whether an approve transaction is required for a given token and either returns the tx
-     *  or null in case the approve is not required
-     *
-     * @param signer
-     * @param token token to approve for
-     * @param amount amount of the token to send
-     * @param spender spending contract address
-     * @param feeRate fee rate to use for the transactions
-     */
-    checkAndGetApproveTx(signer: string, token: string, amount: bigint, spender: string, feeRate?: string): Promise<TransactionRequest | null>;
-    getApproveFee(feeRate?: string): Promise<bigint>;
-    getTransferFee(feeRate?: string): Promise<bigint>;
-}
+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 authorized allowance of specific address towards a spender contract
+     *
+     * @param spender A contract trying to spend user's erc20 balance
+     * @param address Wallet address
+     * @param token ERC-20 token
+     */
+    getTokenAllowance(spender: string, 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>;
+    /**
+     * Checks whether an approve transaction is required for a given token and either returns the tx
+     *  or null in case the approve is not required
+     *
+     * @param signer
+     * @param token token to approve for
+     * @param amount amount of the token to send
+     * @param spender spending contract address
+     * @param feeRate fee rate to use for the transactions
+     */
+    checkAndGetApproveTx(signer: string, token: string, amount: bigint, spender: string, feeRate?: string): Promise<TransactionRequest | null>;
+    getApproveFee(feeRate?: string): Promise<bigint>;
+    getTransferFee(feeRate?: string): Promise<bigint>;
+}