@atomiqlabs/chain-evm 1.0.0-dev.22

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

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

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

@@ -0,0 +1,105 @@
+import { getLogger } from "../../../utils/Utils";
+import {Provider, TransactionRequest} from "ethers";
+
+const MAX_FEE_AGE = 5000;
+
+export type EVMFeeRate = {
+    maxFeePerGas: bigint;
+    maxPriorityFee: bigint;
+};
+
+export class EVMFees {
+
+    private readonly logger = getLogger("EVMFees: ");
+
+    private readonly provider: Provider;
+    private readonly maxFeeRatePerGas: bigint;
+    private readonly priorityFee: bigint;
+
+    private readonly feeMultiplierPPM: bigint;
+
+    private blockFeeCache: {
+        timestamp: number,
+        feeRate: Promise<bigint>
+    } = null;
+
+    constructor(
+        provider: Provider,
+        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 > 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) + 21_000n;
+    }
+
+}

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

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

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

@@ -0,0 +1,115 @@
+import {EVMModule} from "../EVMModule";
+import {Contract, TransactionRequest} from "ethers";
+import {ERC20Abi} from "./ERC20Abi";
+import {EVMAddresses} from "./EVMAddresses";
+import {EVMFees} from "./EVMFees";
+
+
+export class EVMTokens extends EVMModule<any> {
+
+    public static readonly ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+    public static readonly GasCosts = {
+        TRANSFER: 80_000,
+        APPROVE: 80_000
+    };
+
+    private getContract(address: string) {
+        return new Contract(address, ERC20Abi, this.root.provider);
+    }
+
+    ///////////////////
+    //// Tokens
+    /**
+     * Checks if the provided string is a valid starknet token
+     *
+     * @param token
+     */
+    public isValidToken(token: string) {
+        return EVMAddresses.isValidAddress(token);
+    }
+
+    /**
+     * Returns the token balance of the address
+     *
+     * @param address
+     * @param token
+     */
+    public async getTokenBalance(address: string, token: string): Promise<bigint> {
+        let balance: bigint;
+        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
+     */
+    public getNativeCurrencyAddress(): string {
+        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
+     */
+    public async Transfer(signer: string, token: string, amount: bigint, recipient: string, feeRate?: string): Promise<TransactionRequest> {
+        let tx: TransactionRequest;
+        if(token===this.getNativeCurrencyAddress()) {
+            tx = {
+                to: recipient,
+                value: amount
+            };
+        } else {
+            tx = await this.getContract(token).transfer.populateTransaction(recipient, amount);
+        }
+        tx.from = signer;
+        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
+     */
+    public async Approve(signer: string, token: string, amount: bigint, spender: string, feeRate?: string): Promise<TransactionRequest> {
+        if(token===this.getNativeCurrencyAddress()) return null;
+
+        const tx = await this.getContract(token).approve.populateTransaction(spender, amount);
+        tx.from = signer;
+        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;
+    }
+
+}

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

@@ -0,0 +1,246 @@
+import {EVMModule} from "../EVMModule";
+import {Transaction, TransactionRequest} from "ethers";
+import {timeoutPromise} from "../../../utils/Utils";
+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 class EVMTransactions extends EVMModule<any> {
+
+    private readonly latestConfirmedNonces: {[address: string]: number} = {};
+
+    private cbkBeforeTxSigned: (tx: TransactionRequest) => Promise<void>;
+    private cbkSendTransaction: (tx: string) => Promise<string>;
+
+    /**
+     * Waits for transaction confirmation using WS subscription and occasional HTTP polling, also re-sends
+     *  the transaction at regular interval
+     *
+     * @param tx EVM transaction to wait for confirmation for
+     * @param abortSignal signal to abort waiting for tx confirmation
+     * @private
+     */
+    private async confirmTransaction(tx: Transaction, abortSignal?: AbortSignal) {
+        let state = "pending";
+        while(state==="pending" || state==="not_found") {
+            await timeoutPromise(3000, abortSignal);
+            state = await this.getTxIdStatus(tx.hash);
+            //Don't re-send transactions
+            // if(state==="not_found") await this.sendSignedTransaction(tx).catch(e => {
+            //     if(e.baseError?.code === 59) return; //Transaction already in the mempool
+            //     this.logger.error("confirmTransaction(): Error on transaction re-send: ", e);
+            // });
+        }
+        const nextAccountNonce = tx.nonce + 1;
+        const currentNonce = this.latestConfirmedNonces[tx.from];
+        if(currentNonce==null || nextAccountNonce > currentNonce) {
+            this.latestConfirmedNonces[tx.from] = nextAccountNonce;
+        }
+        if(state==="reverted") throw new Error("Transaction reverted!");
+    }
+
+    /**
+     * Prepares starknet transactions, checks if the account is deployed, assigns nonces if needed & calls beforeTxSigned callback
+     *
+     * @param signer
+     * @param txs
+     * @private
+     */
+    private async prepareTransactions(signer: EVMSigner, txs: TransactionRequest[]): Promise<void> {
+        let nonce: number = (await signer.getNonce()) ?? await this.root.provider.getTransactionCount(signer.getAddress(), "pending");
+        const latestConfirmedNonce = this.latestConfirmedNonces[signer.getAddress()];
+        if(latestConfirmedNonce!=null && latestConfirmedNonce > nonce) {
+            this.logger.debug("prepareTransactions(): Using nonce from local cache!");
+            nonce = latestConfirmedNonce;
+        }
+
+        for(let i=0;i<txs.length;i++) {
+            const tx = txs[i];
+            tx.chainId = this.root.evmChainId;
+            tx.from = signer.getAddress();
+            if(tx.nonce!=null) nonce = tx.nonce; //Take the nonce from last tx
+            if(nonce==null) nonce = await this.root.provider.getTransactionCount(signer.getAddress(), "pending"); //Fetch the nonce
+            if(tx.nonce==null) tx.nonce = nonce;
+
+            this.logger.debug("sendAndConfirm(): transaction prepared ("+(i+1)+"/"+txs.length+"), nonce: "+tx.nonce);
+
+            nonce++;
+
+            if(this.cbkBeforeTxSigned!=null) await this.cbkBeforeTxSigned(tx);
+        }
+    }
+
+    /**
+     * 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 async sendSignedTransaction(
+        tx: Transaction,
+        onBeforePublish?: (txId: string, rawTx: string) => Promise<void>,
+    ): Promise<string> {
+        if(onBeforePublish!=null) await onBeforePublish(tx.hash, await this.serializeTx(tx));
+        this.logger.debug("sendSignedTransaction(): sending transaction: ", tx.hash);
+
+        const serializedTx = tx.serialized;
+
+        let result: string;
+        if(this.cbkSendTransaction!=null) result = await this.cbkSendTransaction(serializedTx);
+        if(result==null) {
+            const broadcastResult = await this.provider.broadcastTransaction(tx.serialized);
+            result = broadcastResult.hash;
+        }
+
+        this.logger.info("sendSignedTransaction(): tx sent, txHash: "+result);
+        return result;
+    }
+
+    /**
+     * 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
+     */
+    public async sendAndConfirm(signer: EVMSigner, txs: TransactionRequest[], waitForConfirmation?: boolean, abortSignal?: AbortSignal, parallel?: boolean, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]> {
+        await this.prepareTransactions(signer, txs);
+        const signedTxs: Transaction[] = [];
+
+        //TODO: Maybe don't separate the signing process from the sending when using browser-based wallet,
+        // like with Starknet
+        for(let i=0;i<txs.length;i++) {
+            const tx = txs[i];
+            const signedTx = Transaction.from(await signer.account.signTransaction(tx));
+            signedTxs.push(signedTx);
+            this.logger.debug("sendAndConfirm(): transaction signed ("+(i+1)+"/"+txs.length+"): "+signedTx);
+        }
+
+        this.logger.debug("sendAndConfirm(): sending transactions, count: "+txs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        const txIds: string[] = [];
+        if(parallel) {
+            const promises: Promise<void>[] = [];
+            for(let i=0;i<signedTxs.length;i++) {
+                const signedTx = signedTxs[i];
+                const txId = await this.sendSignedTransaction(signedTx, onBeforePublish);
+                if(waitForConfirmation) promises.push(this.confirmTransaction(signedTx, abortSignal));
+                txIds.push(txId);
+                this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+signedTxs.length+"): "+signedTx.hash);
+            }
+            if(promises.length>0) await Promise.all(promises);
+        } else {
+            for(let i=0;i<signedTxs.length;i++) {
+                const signedTx = signedTxs[i];
+                const txId = await this.sendSignedTransaction(signedTx, onBeforePublish);
+                const confirmPromise = this.confirmTransaction(signedTx, abortSignal);
+                this.logger.debug("sendAndConfirm(): transaction sent ("+(i+1)+"/"+txs.length+"): "+signedTx.hash);
+                //Don't await the last promise when !waitForConfirmation
+                if(i<txs.length-1 || waitForConfirmation) await confirmPromise;
+                txIds.push(txId);
+            }
+        }
+
+        this.logger.info("sendAndConfirm(): sent transactions, count: "+txs.length+
+            " waitForConfirmation: "+waitForConfirmation+" parallel: "+parallel);
+
+        return txIds;
+    }
+
+    /**
+     * Serializes the signed EVM transaction
+     *
+     * @param tx
+     */
+    public serializeTx(tx: Transaction): Promise<string> {
+        return Promise.resolve(tx.serialized);
+    }
+
+    /**
+     * Deserializes signed EVM transaction
+     *
+     * @param txData
+     */
+    public deserializeTx(txData: string): Promise<Transaction> {
+        return Promise.resolve(Transaction.from(txData));
+    }
+
+    /**
+     * Gets the status of the raw starknet transaction
+     *
+     * @param tx
+     */
+    public async getTxStatus(tx: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
+        const parsedTx: Transaction = await this.deserializeTx(tx);
+        return await this.getTxIdStatus(parsedTx.hash);
+    }
+
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    public async getTxIdStatus(txId: string): Promise<"pending" | "success" | "not_found" | "reverted"> {
+        const txResponse = await this.provider.getTransaction(txId);
+        if(txResponse==null) return "not_found";
+        if(txResponse.blockHash==null) return "pending";
+
+        const [safeBlockNumber, txReceipt] = await Promise.all([
+            this.root.config.safeBlockTag==="latest" ? Promise.resolve(null) : this.provider.getBlock(this.root.config.safeBlockTag).then(res => res.number),
+            this.provider.getTransactionReceipt(txId)
+        ]);
+
+        if(txReceipt==null || (safeBlockNumber!=null && txReceipt.blockNumber < safeBlockNumber)) return "pending";
+        if(txReceipt.status===0) return "reverted";
+        return "success";
+    }
+
+    public onBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): void {
+        this.cbkBeforeTxSigned = callback;
+    }
+
+    public offBeforeTxSigned(callback: (tx: TransactionRequest) => Promise<void>): boolean {
+        this.cbkBeforeTxSigned = null;
+        return true;
+    }
+
+    public onSendTransaction(callback: (tx: string) => Promise<string>): void {
+        this.cbkSendTransaction = callback;
+    }
+
+    public offSendTransaction(callback: (tx: string) => Promise<string>): boolean {
+        this.cbkSendTransaction = null;
+        return true;
+    }
+
+    public traceTransaction(txId: string): Promise<EVMTxTrace> {
+        return this.provider.send("debug_traceTransaction", [
+            txId,
+            {
+                tracer: "callTracer"
+            }
+        ]);
+    }
+
+}