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

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;
-    }
-
-    private 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;
+    }
+
+    private 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,81 +1,81 @@
-//@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();
-        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();
+        await this.setupPoll(
+            lastState,
+            (newState: EVMEventListenerState[]) => this.saveLastEventData(newState)
+        );
+    }
+
+}