@atomiqlabs/chain-evm 1.0.0-dev.75 → 1.0.0-dev.77

package/src/evm/contract/EVMContractBase.ts

@@ -1,63 +1,63 @@
-import {BaseContract, Contract, EventFragment, Log, TransactionDescription, EventLog} 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;
-
-type KeysOfType<T, ValueType> = keyof {
-    [K in keyof T]: T[K] extends ValueType ? K : never;
-};
-
-export interface TypedFunctionCall<TCMethod extends TypedContractMethod>
-    extends Omit<TransactionDescription, "args"> {
-    args: __TypechainOutputObject<TCMethod>;
-}
-
-/**
- * Base class providing program specific utilities
- */
-export class EVMContractBase<T extends BaseContract> {
-
-    contract: T;
-
-    public readonly Events: EVMContractEvents<T>;
-    public readonly Chain: EVMChainInterface<any>;
-
-    public readonly contractAddress: string;
-    public readonly contractDeploymentHeight: number;
-
-    constructor(
-        chainInterface: EVMChainInterface<any>,
-        contractAddress: string,
-        contractAbi: any,
-        contractDeploymentHeight?: number,
-    ) {
-        this.Chain = chainInterface;
-        this.contract = new Contract(contractAddress, contractAbi, chainInterface.provider) as unknown as T;
-        this.Events = new EVMContractEvents<T>(chainInterface, this);
-        this.contractAddress = contractAddress;
-        this.contractDeploymentHeight = contractDeploymentHeight;
-    }
-
-    toTypedEvent<TEventName extends keyof T["filters"] = keyof T["filters"]>(log: Log): TypedEventLog<T["filters"][TEventName]> {
-        let foundFragment: EventFragment;
-        try {
-            foundFragment = this.contract.interface.getEvent(log.topics[0]);
-        } catch (error) { }
-        if(!foundFragment) return null;
-
-        try {
-            return new EventLog(log, this.contract.interface, foundFragment) as unknown as TypedEventLog<T["filters"][TEventName]>;
-        } catch (error: any) { }
-    }
-
-    parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod> {
-        return this.contract.interface.parseTransaction({data: calldata}) as unknown as TypedFunctionCall<TMethod>;
-    }
-
-}
+import {BaseContract, Contract, EventFragment, Log, TransactionDescription, EventLog} 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;
+
+type KeysOfType<T, ValueType> = keyof {
+    [K in keyof T]: T[K] extends ValueType ? K : never;
+};
+
+export interface TypedFunctionCall<TCMethod extends TypedContractMethod>
+    extends Omit<TransactionDescription, "args"> {
+    args: __TypechainOutputObject<TCMethod>;
+}
+
+/**
+ * Base class providing program specific utilities
+ */
+export class EVMContractBase<T extends BaseContract> {
+
+    contract: T;
+
+    public readonly Events: EVMContractEvents<T>;
+    public readonly Chain: EVMChainInterface<any>;
+
+    public readonly contractAddress: string;
+    public readonly contractDeploymentHeight: number;
+
+    constructor(
+        chainInterface: EVMChainInterface<any>,
+        contractAddress: string,
+        contractAbi: any,
+        contractDeploymentHeight?: number,
+    ) {
+        this.Chain = chainInterface;
+        this.contract = new Contract(contractAddress, contractAbi, chainInterface.provider) as unknown as T;
+        this.Events = new EVMContractEvents<T>(chainInterface, this);
+        this.contractAddress = contractAddress;
+        this.contractDeploymentHeight = contractDeploymentHeight;
+    }
+
+    toTypedEvent<TEventName extends keyof T["filters"] = keyof T["filters"]>(log: Log): TypedEventLog<T["filters"][TEventName]> {
+        let foundFragment: EventFragment;
+        try {
+            foundFragment = this.contract.interface.getEvent(log.topics[0]);
+        } catch (error) { }
+        if(!foundFragment) return null;
+
+        try {
+            return new EventLog(log, this.contract.interface, foundFragment) as unknown as TypedEventLog<T["filters"][TEventName]>;
+        } catch (error: any) { }
+    }
+
+    parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod> {
+        return this.contract.interface.parseTransaction({data: calldata}) as unknown as TypedFunctionCall<TMethod>;
+    }
+
+}

package/src/evm/contract/EVMContractModule.ts

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

package/src/evm/contract/modules/EVMContractEvents.ts

@@ -1,102 +1,102 @@
-import {BaseContract, Log} from "ethers";
-import {EVMEvents} from "../../chain/modules/EVMEvents";
-import {EVMContractBase} from "../EVMContractBase";
-import {EVMChainInterface} from "../../chain/EVMChainInterface";
-import {TypedEventLog} from "../../typechain/common";
-
-export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
-
-    readonly contract: EVMContractBase<T>;
-    readonly baseContract: T;
-
-    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>) {
-        super(chainInterface);
-        this.contract = contract;
-        this.baseContract = contract.contract;
-    }
-
-    public toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): TypedEventLog<T["filters"][TEventName]>[] {
-        return blockEvents.map(log => this.contract.toTypedEvent<TEventName>(log));
-    }
-
-    private toFilter<TEventName extends keyof T["filters"]>(
-        events: TEventName[],
-        keys: string[],
-    ): (string | string[])[] {
-        const filterArray: (string | string[])[] = [];
-        filterArray.push(events.map(name => {
-            return this.baseContract.getEvent(name as string).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
-     */
-    public async getContractBlockEvents<TEventName extends keyof T["filters"]>(
-        events: TEventName[],
-        keys: string[],
-        startBlockHeight?: number,
-        endBlockHeight: number = startBlockHeight
-    ): Promise<TypedEventLog<T["filters"][TEventName]>[]> {
-        const blockEvents = await super.getBlockEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), startBlockHeight, endBlockHeight);
-        return this.toTypedEvents<TEventName>(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
-     */
-    public async findInContractEvents<TResult, TEventName extends keyof T["filters"]>(
-        events: TEventName[],
-        keys: string[],
-        processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
-        abortSignal?: AbortSignal
-    ): Promise<TResult> {
-        return this.findInEvents<TResult>(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events: Log[]) => {
-            const parsedEvents = this.toTypedEvents<TEventName>(events);
-            for(let event of parsedEvents) {
-                const result: TResult = 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
-     */
-    public async findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(
-        events: TEventName[],
-        keys: string[],
-        processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
-        abortSignal?: AbortSignal
-    ): Promise<TResult> {
-        return this.findInEventsForward<TResult>(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events: Log[]) => {
-            const parsedEvents = this.toTypedEvents<TEventName>(events);
-            for(let event of parsedEvents) {
-                const result: TResult = await processor(event);
-                if(result!=null) return result;
-            }
-        }, abortSignal, this.contract.contractDeploymentHeight);
-    }
-
-}
-
+import {BaseContract, Log} from "ethers";
+import {EVMEvents} from "../../chain/modules/EVMEvents";
+import {EVMContractBase} from "../EVMContractBase";
+import {EVMChainInterface} from "../../chain/EVMChainInterface";
+import {TypedEventLog} from "../../typechain/common";
+
+export class EVMContractEvents<T extends BaseContract> extends EVMEvents {
+
+    readonly contract: EVMContractBase<T>;
+    readonly baseContract: T;
+
+    constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>) {
+        super(chainInterface);
+        this.contract = contract;
+        this.baseContract = contract.contract;
+    }
+
+    public toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): TypedEventLog<T["filters"][TEventName]>[] {
+        return blockEvents.map(log => this.contract.toTypedEvent<TEventName>(log));
+    }
+
+    private toFilter<TEventName extends keyof T["filters"]>(
+        events: TEventName[],
+        keys: string[],
+    ): (string | string[])[] {
+        const filterArray: (string | string[])[] = [];
+        filterArray.push(events.map(name => {
+            return this.baseContract.getEvent(name as string).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
+     */
+    public async getContractBlockEvents<TEventName extends keyof T["filters"]>(
+        events: TEventName[],
+        keys: string[],
+        startBlockHeight?: number,
+        endBlockHeight: number = startBlockHeight
+    ): Promise<TypedEventLog<T["filters"][TEventName]>[]> {
+        const blockEvents = await super.getBlockEvents(await this.baseContract.getAddress(), this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toTypedEvents<TEventName>(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
+     */
+    public async findInContractEvents<TResult, TEventName extends keyof T["filters"]>(
+        events: TEventName[],
+        keys: string[],
+        processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
+        abortSignal?: AbortSignal
+    ): Promise<TResult> {
+        return this.findInEvents<TResult>(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events: Log[]) => {
+            const parsedEvents = this.toTypedEvents<TEventName>(events);
+            for(let event of parsedEvents) {
+                const result: TResult = 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
+     */
+    public async findInContractEventsForward<TResult, TEventName extends keyof T["filters"]>(
+        events: TEventName[],
+        keys: string[],
+        processor: (event: TypedEventLog<T["filters"][TEventName]>) => Promise<TResult>,
+        abortSignal?: AbortSignal
+    ): Promise<TResult> {
+        return this.findInEventsForward<TResult>(await this.baseContract.getAddress(), this.toFilter(events, keys), async (events: Log[]) => {
+            const parsedEvents = this.toTypedEvents<TEventName>(events);
+            for(let event of parsedEvents) {
+                const result: TResult = await processor(event);
+                if(result!=null) return result;
+            }
+        }, abortSignal, this.contract.contractDeploymentHeight);
+    }
+
+}
+

package/src/evm/events/EVMChainEvents.ts

@@ -1,82 +1,82 @@
-//@ts-ignore
-import * as fs from "fs/promises";
-import {EVMChainEventsBrowser, EVMEventListenerState} from "./EVMChainEventsBrowser";
-import {EVMChainInterface} from "../chain/EVMChainInterface";
-import {EVMSwapContract} from "../swaps/EVMSwapContract";
-import {EVMSpvVaultContract} from "../spv_swap/EVMSpvVaultContract";
-
-
-export class EVMChainEvents extends EVMChainEventsBrowser {
-
-    private readonly directory: string;
-    private readonly BLOCKHEIGHT_FILENAME: string;
-
-    constructor(
-        directory: string,
-        chainInterface: EVMChainInterface,
-        evmSwapContract: EVMSwapContract,
-        evmSpvVaultContract: EVMSpvVaultContract<any>,
-        pollIntervalSeconds?: number
-    ) {
-        super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
-        this.BLOCKHEIGHT_FILENAME = "/"+chainInterface.chainId+"-blockheight.txt";
-        this.directory = directory;
-    }
-
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private async getLastEventData(): Promise<EVMEventListenerState[]> {
-        try {
-            const txt: string = (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
-     */
-    private saveLastEventData(newState: EVMEventListenerState[]): Promise<void> {
-        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(): Promise<void> {
-        const lastState = await this.getLastEventData();
-        if((this.provider as any).websocket!=null) await this.setupWebsocket();
-        await this.setupPoll(
-            lastState,
-            (newState: EVMEventListenerState[]) => this.saveLastEventData(newState)
-        );
-    }
-
-}
+//@ts-ignore
+import * as fs from "fs/promises";
+import {EVMChainEventsBrowser, EVMEventListenerState} from "./EVMChainEventsBrowser";
+import {EVMChainInterface} from "../chain/EVMChainInterface";
+import {EVMSwapContract} from "../swaps/EVMSwapContract";
+import {EVMSpvVaultContract} from "../spv_swap/EVMSpvVaultContract";
+
+
+export class EVMChainEvents extends EVMChainEventsBrowser {
+
+    private readonly directory: string;
+    private readonly BLOCKHEIGHT_FILENAME: string;
+
+    constructor(
+        directory: string,
+        chainInterface: EVMChainInterface,
+        evmSwapContract: EVMSwapContract,
+        evmSpvVaultContract: EVMSpvVaultContract<any>,
+        pollIntervalSeconds?: number
+    ) {
+        super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
+        this.BLOCKHEIGHT_FILENAME = "/"+chainInterface.chainId+"-blockheight.txt";
+        this.directory = directory;
+    }
+
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private async getLastEventData(): Promise<EVMEventListenerState[]> {
+        try {
+            const txt: string = (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
+     */
+    private saveLastEventData(newState: EVMEventListenerState[]): Promise<void> {
+        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(): Promise<void> {
+        const lastState = await this.getLastEventData();
+        if((this.provider as any).websocket!=null) await this.setupWebsocket();
+        await this.setupPoll(
+            lastState,
+            (newState: EVMEventListenerState[]) => this.saveLastEventData(newState)
+        );
+    }
+
+}