@atomiqlabs/chain-evm 1.0.0-dev.100

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

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

@@ -0,0 +1,142 @@
+"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 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
+     */
+    async getTokenAllowance(spender, address, token) {
+        if (token === "0x0000000000000000000000000000000000000000")
+            return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
+        const erc20 = this.getContract(token);
+        return await erc20.allowance(address, spender);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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
+     */
+    async checkAndGetApproveTx(signer, token, amount, spender, feeRate) {
+        const alreadyApproved = await this.getTokenAllowance(spender, signer, token);
+        if (alreadyApproved >= amount)
+            return null;
+        return await this.Approve(signer, token, amount, spender, feeRate);
+    }
+    async getApproveFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
+    async getTransferFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
+}
+exports.EVMTokens = EVMTokens;
+EVMTokens.ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+EVMTokens.GasCosts = {
+    TRANSFER: 80000 + 21000,
+    APPROVE: 80000 + 21000
+};

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

@@ -0,0 +1,94 @@
+import { EVMModule } from "../EVMModule";
+import { Transaction, TransactionRequest } from "ethers";
+import { EVMSigner } from "../../wallet/EVMSigner";
+export type EVMTx = TransactionRequest;
+export type EVMTxTrace = {
+    from: string;
+    gas: string;
+    gasused: string;
+    to: string;
+    input: string;
+    output: string;
+    error: string;
+    revertReason: string;
+    calls: EVMTxTrace[];
+    type: "CREATE" | "CALL" | "STATICCALL";
+};
+export declare class EVMTransactions extends EVMModule<any> {
+    private readonly latestConfirmedNonces;
+    private readonly latestPendingNonces;
+    private readonly latestSignedNonces;
+    readonly _cbksBeforeTxReplace: ((oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>)[];
+    private readonly cbksBeforeTxSigned;
+    private cbkSendTransaction;
+    readonly _knownTxSet: Set<string>;
+    /**
+     * Waits for transaction confirmation using HTTP polling
+     *
+     * @param tx EVM transaction to wait for confirmation for
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    private confirmTransaction;
+    /**
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     *
+     * @param signer
+     * @param txs
+     * @private
+     */
+    private prepareTransactions;
+    /**
+     * Sends out a signed transaction to the RPC
+     *
+     * @param tx EVM tx to send
+     * @param onBeforePublish a callback called before every transaction is published
+     * @private
+     */
+    private sendSignedTransaction;
+    /**
+     * Prepares, signs, sends (in parallel or sequentially) & optionally waits for confirmation
+     *  of a batch of EVM transactions
+     *
+     * @param signer
+     * @param txs transactions to send
+     * @param waitForConfirmation whether to wait for transaction confirmations (this also makes sure the transactions
+     *  are re-sent at regular intervals)
+     * @param abortSignal abort signal to abort waiting for transaction confirmations
+     * @param parallel whether the send all the transaction at once in parallel or sequentially (such that transactions
+     *  are executed in order)
+     * @param onBeforePublish a callback called before every transaction is published, NOTE: callback is not called when using browser-based wallet!
+     */
+    sendAndConfirm(signer: EVMSigner, txs: TransactionRequest[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
+    /**
+     * Serializes the signed EVM transaction
+     *
+     * @param tx
+     */
+    serializeTx(tx: Transaction): Promise<string>;
+    /**
+     * Deserializes signed EVM transaction
+     *
+     * @param txData
+     */
+    deserializeTx(txData: string): Promise<Transaction>;
+    /**
+     * Gets the status of the raw starknet transaction
+     *
+     * @param tx
+     */
+    getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    /**
+     * Gets the status of the EVM transaction with a specific txId
+     *
+     * @param txId
+     */
+    getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted">;
+    onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void;
+    offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean;
+    onSendTransaction(callback: (tx: string) => Promise<string>): void;
+    offSendTransaction(callback: (tx: string) => Promise<string>): boolean;
+    onBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): void;
+    offBeforeTxReplace(callback: (oldTx: string, oldTxId: string, newTx: string, newTxId: string) => Promise<void>): boolean;
+    traceTransaction(txId: string): Promise<EVMTxTrace>;
+}