@atomiqlabs/chain-evm 1.0.0-dev.22

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

@@ -0,0 +1,89 @@
+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 cbkBeforeTxSigned;
+    private cbkSendTransaction;
+    /**
+     * 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 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
+     */
+    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 starknet 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;
+    traceTransaction(txId: string): Promise<EVMTxTrace>;
+}

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMTransactions = void 0;
+const EVMModule_1 = require("../EVMModule");
+const ethers_1 = require("ethers");
+const Utils_1 = require("../../../utils/Utils");
+class EVMTransactions extends EVMModule_1.EVMModule {
+    constructor() {
+        super(...arguments);
+        this.latestConfirmedNonces = {};
+    }
+    /**
+     * 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
+     */
+    async confirmTransaction(tx, abortSignal) {
+        let state = "pending";
+        while (state === "pending" || state === "not_found") {
+            await (0, Utils_1.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
+     */
+    async prepareTransactions(signer, txs) {
+        let nonce = (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
+     */
+    async sendSignedTransaction(tx, onBeforePublish) {
+        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;
+        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
+     */
+    async sendAndConfirm(signer, txs, waitForConfirmation, abortSignal, parallel, onBeforePublish) {
+        await this.prepareTransactions(signer, txs);
+        const signedTxs = [];
+        //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 = ethers_1.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 = [];
+        if (parallel) {
+            const promises = [];
+            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
+     */
+    serializeTx(tx) {
+        return Promise.resolve(tx.serialized);
+    }
+    /**
+     * Deserializes signed EVM transaction
+     *
+     * @param txData
+     */
+    deserializeTx(txData) {
+        return Promise.resolve(ethers_1.Transaction.from(txData));
+    }
+    /**
+     * Gets the status of the raw starknet transaction
+     *
+     * @param tx
+     */
+    async getTxStatus(tx) {
+        const parsedTx = await this.deserializeTx(tx);
+        return await this.getTxIdStatus(parsedTx.hash);
+    }
+    /**
+     * Gets the status of the starknet transaction with a specific txId
+     *
+     * @param txId
+     */
+    async getTxIdStatus(txId) {
+        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";
+    }
+    onBeforeTxSigned(callback) {
+        this.cbkBeforeTxSigned = callback;
+    }
+    offBeforeTxSigned(callback) {
+        this.cbkBeforeTxSigned = null;
+        return true;
+    }
+    onSendTransaction(callback) {
+        this.cbkSendTransaction = callback;
+    }
+    offSendTransaction(callback) {
+        this.cbkSendTransaction = null;
+        return true;
+    }
+    traceTransaction(txId) {
+        return this.provider.send("debug_traceTransaction", [
+            txId,
+            {
+                tracer: "callTracer"
+            }
+        ]);
+    }
+}
+exports.EVMTransactions = EVMTransactions;

package/dist/evm/contract/EVMContractBase.d.ts

@@ -0,0 +1,22 @@
+import { BaseContract, Log, TransactionDescription } from "ethers";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMContractEvents } from "./modules/EVMContractEvents";
+import { TypedContractMethod, TypedEventLog } from "../typechain/common";
+type __TypechainOutputObject<T> = T extends TypedContractMethod<infer V> ? V : never;
+export interface TypedFunctionCall<TCMethod extends TypedContractMethod> extends Omit<TransactionDescription, "args"> {
+    args: __TypechainOutputObject<TCMethod>;
+}
+/**
+ * Base class providing program specific utilities
+ */
+export declare class EVMContractBase<T extends BaseContract> {
+    contract: T;
+    readonly Events: EVMContractEvents<T>;
+    readonly Chain: EVMChainInterface<any>;
+    readonly contractAddress: string;
+    readonly contractDeploymentHeight: number;
+    constructor(chainInterface: EVMChainInterface<any>, contractAddress: string, contractAbi: any, contractDeploymentHeight?: number);
+    toTypedEvent<TEventName extends keyof T["filters"] = keyof T["filters"]>(log: Log): TypedEventLog<T["filters"][TEventName]>;
+    parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod>;
+}
+export {};

package/dist/evm/contract/EVMContractBase.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMContractBase = void 0;
+const ethers_1 = require("ethers");
+const EVMContractEvents_1 = require("./modules/EVMContractEvents");
+/**
+ * Base class providing program specific utilities
+ */
+class EVMContractBase {
+    constructor(chainInterface, contractAddress, contractAbi, contractDeploymentHeight) {
+        this.Chain = chainInterface;
+        this.contract = new ethers_1.Contract(contractAddress, contractAbi, chainInterface.provider);
+        this.Events = new EVMContractEvents_1.EVMContractEvents(chainInterface, this);
+        this.contractAddress = contractAddress;
+        this.contractDeploymentHeight = contractDeploymentHeight;
+    }
+    toTypedEvent(log) {
+        let foundFragment;
+        try {
+            foundFragment = this.contract.interface.getEvent(log.topics[0]);
+        }
+        catch (error) { }
+        if (!foundFragment)
+            return null;
+        try {
+            return new ethers_1.EventLog(log, this.contract.interface, foundFragment);
+        }
+        catch (error) { }
+    }
+    parseCalldata(calldata) {
+        return this.contract.interface.parseTransaction({ data: calldata });
+    }
+}
+exports.EVMContractBase = EVMContractBase;

package/dist/evm/contract/EVMContractModule.d.ts

@@ -0,0 +1,8 @@
+import { BaseContract } from "ethers";
+import { EVMModule } from "../chain/EVMModule";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMContractBase } from "./EVMContractBase";
+export declare class EVMContractModule<T extends BaseContract> extends EVMModule<any> {
+    readonly contract: EVMContractBase<T>;
+    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
+}

package/dist/evm/contract/EVMContractModule.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMContractModule = void 0;
+const EVMModule_1 = require("../chain/EVMModule");
+class EVMContractModule extends EVMModule_1.EVMModule {
+    constructor(chainInterface, contract) {
+        super(chainInterface);
+        this.contract = contract;
+    }
+}
+exports.EVMContractModule = EVMContractModule;

package/dist/evm/contract/modules/EVMContractEvents.d.ts

@@ -0,0 +1,42 @@
+import { BaseContract } from "ethers";
+import { EVMEvents } from "../../chain/modules/EVMEvents";
+import { EVMContractBase } from "../EVMContractBase";
+import { EVMChainInterface } from "../../chain/EVMChainInterface";
+import { TypedEventLog } from "../../typechain/common";
+export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents {
+    readonly contract: EVMContractBase<T>;
+    readonly baseContract: T;
+    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
+    private toTypedEvents;
+    private toFilter;
+    /**
+     * Returns the events occuring in a range of EVM blocks as identified by the contract and keys,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    getContractBlockEvents<TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], startBlockHeight?: number, endBlockHeight?: number): Promise<TypedEventLog<T["filters"][TEventName]>[]>;
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEvents<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(events: TEventName[], keys: string[], processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>, abortSignal?: AbortSignal): Promise<TResult>;
+}

package/dist/evm/contract/modules/EVMContractEvents.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMContractEvents = void 0;
+const EVMEvents_1 = require("../../chain/modules/EVMEvents");
+class EVMContractEvents extends EVMEvents_1.EVMEvents {
+    constructor(chainInterface, contract) {
+        super(chainInterface);
+        this.contract = contract;
+        this.baseContract = contract.contract;
+    }
+    toTypedEvents(blockEvents) {
+        return blockEvents.map(log => this.contract.toTypedEvent(log));
+    }
+    toFilter(events, keys) {
+        const filterArray = [];
+        filterArray.push(events.map(name => {
+            return this.baseContract.getEvent(name).fragment.topicHash;
+        }));
+        if (keys != null)
+            keys.forEach(key => filterArray.push(key));
+        return filterArray;
+    }
+    /**
+     * Returns the events occuring in a range of EVM blocks as identified by the contract and keys,
+     *  returns pending events if no startHeight & endHeight is passed
+     *
+     * @param events
+     * @param keys
+     * @param startBlockHeight
+     * @param endBlockHeight
+     */
+    async getContractBlockEvents(events, keys, startBlockHeight, endBlockHeight = startBlockHeight) {
+        const blockEvents = await super.getBlockEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toTypedEvents(blockEvents);
+    }
+    /**
+     * Runs a search backwards in time, processing the events for a specific topic public key
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEvents(events, keys, processor, abortSignal) {
+        return this.findInEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toTypedEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal, this.contract.contractDeploymentHeight);
+    }
+    /**
+     * Runs a search forwards in time, processing the events for a specific topic
+     *
+     * @param events
+     * @param keys
+     * @param processor called for every event, should return a value if the correct event was found, or null
+     *  if the search should continue
+     * @param abortSignal
+     */
+    async findInContractEventsForward(events, keys, processor, abortSignal) {
+        return this.findInEventsForward(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toTypedEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+        }, abortSignal, this.contract.contractDeploymentHeight);
+    }
+}
+exports.EVMContractEvents = EVMContractEvents;

package/dist/evm/events/EVMChainEvents.d.ts

@@ -0,0 +1,22 @@
+import { EVMChainEventsBrowser } from "./EVMChainEventsBrowser";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import { EVMSwapContract } from "../swaps/EVMSwapContract";
+import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
+export declare class EVMChainEvents extends EVMChainEventsBrowser {
+    private readonly directory;
+    private readonly BLOCKHEIGHT_FILENAME;
+    constructor(directory: string, chainInterface: EVMChainInterface, evmSwapContract: EVMSwapContract, evmSpvVaultContract: EVMSpvVaultContract<any>, pollIntervalSeconds?: number);
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private getLastEventData;
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    private saveLastEventData;
+    init(): Promise<void>;
+}

package/dist/evm/events/EVMChainEvents.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMChainEvents = void 0;
+//@ts-ignore
+const fs = require("fs/promises");
+const EVMChainEventsBrowser_1 = require("./EVMChainEventsBrowser");
+class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
+    constructor(directory, chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds) {
+        super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
+        this.BLOCKHEIGHT_FILENAME = "/" + chainInterface.chainId + "-blockheight.txt";
+        this.directory = directory;
+    }
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    async getLastEventData() {
+        try {
+            const txt = (await fs.readFile(this.directory + this.BLOCKHEIGHT_FILENAME)).toString();
+            const arr = txt.split(";");
+            return arr.map(val => {
+                const stateResult = val.split(",");
+                if (stateResult.length >= 3) {
+                    return {
+                        lastBlockNumber: parseInt(stateResult[0]),
+                        lastEvent: {
+                            blockHash: stateResult[1],
+                            logIndex: parseInt(stateResult[2])
+                        }
+                    };
+                }
+                else if (stateResult.length >= 1) {
+                    return {
+                        lastBlockNumber: parseInt(stateResult[0])
+                    };
+                }
+                else {
+                    return null;
+                }
+            });
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(newState) {
+        return fs.writeFile(this.directory + this.BLOCKHEIGHT_FILENAME, newState.map(val => {
+            if (val.lastEvent == null) {
+                return val.lastBlockNumber.toString(10);
+            }
+            else {
+                return val.lastBlockNumber.toString(10) + "," + val.lastEvent.blockHash + "," + val.lastEvent.logIndex.toString(10);
+            }
+        }).join(";"));
+    }
+    async init() {
+        const lastState = await this.getLastEventData();
+        await this.setupPoll(lastState, (newState) => this.saveLastEventData(newState));
+    }
+}
+exports.EVMChainEvents = EVMChainEvents;