@atomiqlabs/chain-starknet 8.0.13 → 8.1.10

package/dist/starknet/contract/StarknetContractBase.d.ts

@@ -1,13 +1,14 @@
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { TypedContractV2 } from "starknet";
-import { Abi } from "abi-wan-kanabi";
-import { StarknetContractEvents } from "./modules/StarknetContractEvents";
-/**
- * Base class providing program specific utilities
- */
-export declare class StarknetContractBase<T extends Abi> {
-    contract: TypedContractV2<T>;
-    readonly Events: StarknetContractEvents<T>;
-    readonly Chain: StarknetChainInterface;
-    constructor(chainInterface: StarknetChainInterface, contractAddress: string, contractAbi: T);
-}
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { TypedContractV2 } from "starknet";
+import { Abi } from "abi-wan-kanabi";
+import { StarknetContractEvents } from "./modules/StarknetContractEvents";
+/**
+ * Base class providing program specific utilities
+ */
+export declare class StarknetContractBase<T extends Abi> {
+    readonly contract: TypedContractV2<T>;
+    readonly Events: StarknetContractEvents<T>;
+    readonly Chain: StarknetChainInterface;
+    readonly contractDeploymentHeight?: number;
+    constructor(chainInterface: StarknetChainInterface, contractAddress: string, contractAbi: T, contractDeploymentHeight?: number);
+}

package/dist/starknet/contract/StarknetContractBase.js

@@ -1,20 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetContractBase = void 0;
-const starknet_1 = require("starknet");
-const StarknetContractEvents_1 = require("./modules/StarknetContractEvents");
-/**
- * Base class providing program specific utilities
- */
-class StarknetContractBase {
-    constructor(chainInterface, contractAddress, contractAbi) {
-        this.Chain = chainInterface;
-        this.contract = new starknet_1.Contract({
-            abi: contractAbi,
-            address: contractAddress,
-            providerOrAccount: chainInterface.provider
-        }).typedv2(contractAbi);
-        this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
-    }
-}
-exports.StarknetContractBase = StarknetContractBase;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractBase = void 0;
+const starknet_1 = require("starknet");
+const StarknetContractEvents_1 = require("./modules/StarknetContractEvents");
+/**
+ * Base class providing program specific utilities
+ */
+class StarknetContractBase {
+    constructor(chainInterface, contractAddress, contractAbi, contractDeploymentHeight) {
+        this.Chain = chainInterface;
+        this.contract = new starknet_1.Contract({
+            abi: contractAbi,
+            address: contractAddress,
+            providerOrAccount: chainInterface.provider
+        }).typedv2(contractAbi);
+        this.Events = new StarknetContractEvents_1.StarknetContractEvents(chainInterface, this, contractAbi);
+        this.contractDeploymentHeight = contractDeploymentHeight;
+    }
+}
+exports.StarknetContractBase = StarknetContractBase;

package/dist/starknet/contract/StarknetContractModule.d.ts

@@ -1,8 +1,8 @@
-import { Abi } from "abi-wan-kanabi";
-import { StarknetContractBase } from "./StarknetContractBase";
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { StarknetModule } from "../chain/StarknetModule";
-export declare class StarknetContractModule<TAbi extends Abi> extends StarknetModule {
-    readonly contract: StarknetContractBase<TAbi>;
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>);
-}
+import { Abi } from "abi-wan-kanabi";
+import { StarknetContractBase } from "./StarknetContractBase";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { StarknetModule } from "../chain/StarknetModule";
+export declare class StarknetContractModule<TAbi extends Abi> extends StarknetModule {
+    protected readonly contract: StarknetContractBase<TAbi>;
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>);
+}

package/dist/starknet/contract/StarknetContractModule.js

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

package/dist/starknet/contract/modules/StarknetContractEvents.d.ts

@@ -1,57 +1,56 @@
-import { Abi } from "abi-wan-kanabi";
-import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
-import { StarknetEvent, StarknetEvents } from "../../chain/modules/StarknetEvents";
-import { AbiEvents, AbiStructs, AbiEnums } from "starknet";
-import { StarknetContractBase } from "../StarknetContractBase";
-import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
-export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
-    name: TEventName;
-    params: EventToPrimitiveType<TAbi, TEventName>;
-    txHash: string;
-    blockHash?: string;
-    blockNumber?: number;
-    keys: string[];
-    data: string[];
-};
-export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
-    readonly contract: StarknetContractBase<TAbi>;
-    readonly abi: TAbi;
-    readonly knownEventNames: string[];
-    readonly abiEvents: AbiEvents;
-    readonly abiStructs: AbiStructs;
-    readonly abiEnums: AbiEnums;
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
-    toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[];
-    toFilter<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: null | (null | string | string[])[]): string[][];
-    /**
-     * Returns the events occuring in a range of starknet block 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<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: (null | string | string[])[], startBlockHeight?: number, endBlockHeight?: number | null): Promise<StarknetAbiEvent<TAbi, T>[]>;
-    /**
-     * 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<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: null | (null | string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T | null>, abortSignal?: AbortSignal): Promise<T | null>;
-    /**
-     * Runs a search forwards 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 startHeight
-     * @param abortSignal
-     */
-    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: null | (null | string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T | null>, startHeight?: number, abortSignal?: AbortSignal): Promise<T | null>;
-}
+import { Abi } from "abi-wan-kanabi";
+import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
+import { StarknetEvent, StarknetEvents } from "../../chain/modules/StarknetEvents";
+import { StarknetContractBase } from "../StarknetContractBase";
+import { StarknetChainInterface } from "../../chain/StarknetChainInterface";
+export type StarknetAbiEvent<TAbi extends Abi, TEventName extends ExtractAbiEventNames<TAbi>> = {
+    name: TEventName;
+    params: EventToPrimitiveType<TAbi, TEventName>;
+    txHash: string;
+    blockHash?: string;
+    blockNumber?: number;
+    keys: string[];
+    data: string[];
+};
+export declare class StarknetContractEvents<TAbi extends Abi> extends StarknetEvents {
+    private readonly contract;
+    private readonly abi;
+    private readonly knownEventNames;
+    private readonly abiEvents;
+    private readonly abiStructs;
+    private readonly abiEnums;
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
+    toStarknetAbiEvents<T extends ExtractAbiEventNames<TAbi>>(blockEvents: StarknetEvent[]): StarknetAbiEvent<TAbi, T>[];
+    toFilter<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: null | (null | string | string[])[]): string[][];
+    /**
+     * Returns the events occuring in a range of starknet block 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<T extends ExtractAbiEventNames<TAbi>>(events: T[], keys: (null | string | string[])[], startBlockHeight?: number, endBlockHeight?: number | null): Promise<StarknetAbiEvent<TAbi, T>[]>;
+    /**
+     * 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<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: null | (null | string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T | null>, abortSignal?: AbortSignal): Promise<T | null>;
+    /**
+     * Runs a search forwards 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 startHeight
+     * @param abortSignal
+     */
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: null | (null | string | string[])[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T | null>, startHeight?: number, abortSignal?: AbortSignal): Promise<T | null>;
+}

package/dist/starknet/contract/modules/StarknetContractEvents.js

@@ -1,111 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetContractEvents = void 0;
-const StarknetEvents_1 = require("../../chain/modules/StarknetEvents");
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../../utils/Utils");
-class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
-    constructor(chainInterface, contract, abi) {
-        super(chainInterface);
-        this.contract = contract;
-        this.abi = abi;
-        this.abiEvents = starknet_1.events.getAbiEvents(this.abi);
-        this.abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
-        this.abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
-        this.knownEventNames = Object.keys(this.abiEvents).map(hash => this.abiEvents[hash].name);
-    }
-    toStarknetAbiEvents(blockEvents) {
-        return blockEvents.map((starknetEvent) => {
-            // Convert StarknetEvent to EMITTED_EVENT format expected by parseEvents
-            const [value] = starknet_1.events.parseEvents([{
-                    ...starknetEvent,
-                    transaction_index: starknetEvent.transaction_index ?? 0,
-                    event_index: starknetEvent.event_index ?? 0
-                }], this.abiEvents, this.abiStructs, this.abiEnums, (0, starknet_1.createAbiParser)(this.abi));
-            if (value == null)
-                throw new Error("Invalid event detected, please check provided ABI");
-            const name = Object.keys(value).find(name => this.knownEventNames.includes(name));
-            if (name == null)
-                throw new Error("Invalid event detected (name), please check provided ABI");
-            const event = {
-                name: name,
-                txHash: starknetEvent.transaction_hash,
-                params: value[name],
-                blockNumber: starknetEvent.block_number,
-                blockHash: starknetEvent.block_hash,
-                data: starknetEvent.data,
-                keys: starknetEvent.keys
-            };
-            // this.logger.debug("toStarknetAbiEvents(): Parsed event: ", event);
-            return event;
-        });
-    }
-    toFilter(events, keys) {
-        const filterArray = [];
-        filterArray.push(events.map(name => {
-            const arr = name.split(":");
-            const eventName = arr[arr.length - 1];
-            return (0, Utils_1.toHex)(starknet_1.hash.starknetKeccak(eventName), 0);
-        }));
-        if (keys != null)
-            keys.forEach(key => filterArray.push(key == null ? [] : Array.isArray(key) ? key.map(k => (0, Utils_1.toHex)(k, 0)) : [(0, Utils_1.toHex)(key, 0)]));
-        return filterArray;
-    }
-    /**
-     * Returns the events occuring in a range of starknet block 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) {
-        if (endBlockHeight === undefined)
-            endBlockHeight = startBlockHeight;
-        const blockEvents = await super.getBlockEvents(this.contract.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
-        return this.toStarknetAbiEvents(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(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toStarknetAbiEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-            return null;
-        }, abortSignal);
-    }
-    /**
-     * Runs a search forwards 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 startHeight
-     * @param abortSignal
-     */
-    async findInContractEventsForward(events, keys, processor, startHeight, abortSignal) {
-        return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
-            const parsedEvents = this.toStarknetAbiEvents(events);
-            for (let event of parsedEvents) {
-                const result = await processor(event);
-                if (result != null)
-                    return result;
-            }
-            return null;
-        }, startHeight, abortSignal);
-    }
-}
-exports.StarknetContractEvents = StarknetContractEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetContractEvents = void 0;
+const StarknetEvents_1 = require("../../chain/modules/StarknetEvents");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../utils/Utils");
+class StarknetContractEvents extends StarknetEvents_1.StarknetEvents {
+    constructor(chainInterface, contract, abi) {
+        super(chainInterface);
+        this.contract = contract;
+        this.abi = abi;
+        this.abiEvents = starknet_1.events.getAbiEvents(this.abi);
+        this.abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
+        this.abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
+        this.knownEventNames = Object.keys(this.abiEvents).map(hash => this.abiEvents[hash].name);
+    }
+    toStarknetAbiEvents(blockEvents) {
+        return blockEvents.map((starknetEvent) => {
+            // Convert StarknetEvent to EMITTED_EVENT format expected by parseEvents
+            const [value] = starknet_1.events.parseEvents([{
+                    ...starknetEvent,
+                    transaction_index: starknetEvent.transaction_index ?? 0,
+                    event_index: starknetEvent.event_index ?? 0
+                }], this.abiEvents, this.abiStructs, this.abiEnums, (0, starknet_1.createAbiParser)(this.abi));
+            if (value == null)
+                throw new Error("Invalid event detected, please check provided ABI");
+            const name = Object.keys(value).find(name => this.knownEventNames.includes(name));
+            if (name == null)
+                throw new Error("Invalid event detected (name), please check provided ABI");
+            const event = {
+                name: name,
+                txHash: starknetEvent.transaction_hash,
+                params: value[name],
+                blockNumber: starknetEvent.block_number,
+                blockHash: starknetEvent.block_hash,
+                data: starknetEvent.data,
+                keys: starknetEvent.keys
+            };
+            // this.logger.debug("toStarknetAbiEvents(): Parsed event: ", event);
+            return event;
+        });
+    }
+    toFilter(events, keys) {
+        const filterArray = [];
+        filterArray.push(events.map(name => {
+            const arr = name.split(":");
+            const eventName = arr[arr.length - 1];
+            return (0, Utils_1.toHex)(starknet_1.hash.starknetKeccak(eventName), 0);
+        }));
+        if (keys != null)
+            keys.forEach(key => filterArray.push(key == null ? [] : Array.isArray(key) ? key.map(k => (0, Utils_1.toHex)(k, 0)) : [(0, Utils_1.toHex)(key, 0)]));
+        return filterArray;
+    }
+    /**
+     * Returns the events occuring in a range of starknet block 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) {
+        if (endBlockHeight === undefined)
+            endBlockHeight = startBlockHeight;
+        const blockEvents = await super.getBlockEvents(this.contract.contract.address, this.toFilter(events, keys), startBlockHeight, endBlockHeight);
+        return this.toStarknetAbiEvents(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(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toStarknetAbiEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+            return null;
+        }, abortSignal);
+    }
+    /**
+     * Runs a search forwards 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 startHeight
+     * @param abortSignal
+     */
+    async findInContractEventsForward(events, keys, processor, startHeight, abortSignal) {
+        return this.findInEventsForward(this.contract.contract.address, this.toFilter(events, keys), async (events) => {
+            const parsedEvents = this.toStarknetAbiEvents(events);
+            for (let event of parsedEvents) {
+                const result = await processor(event);
+                if (result != null)
+                    return result;
+            }
+            return null;
+        }, Math.max(startHeight ?? 0, this.contract.contractDeploymentHeight ?? 0), abortSignal);
+    }
+}
+exports.StarknetContractEvents = StarknetContractEvents;

package/dist/starknet/events/StarknetChainEvents.d.ts

@@ -1,21 +1,21 @@
-import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
-import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
-export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
-    private readonly directory;
-    constructor(directory: string, chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private getLastEventData;
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    private saveLastEventData;
-    init(noAutomaticPoll?: boolean): Promise<void>;
-}
+import { StarknetChainEventsBrowser } from "./StarknetChainEventsBrowser";
+import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
+export declare class StarknetChainEvents extends StarknetChainEventsBrowser {
+    private readonly directory;
+    constructor(directory: string, chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private getLastEventData;
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    private saveLastEventData;
+    init(noAutomaticPoll?: boolean): Promise<void>;
+}

package/dist/starknet/events/StarknetChainEvents.js

@@ -1,61 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetChainEvents = void 0;
-const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
-//@ts-ignore
-const fs = require("fs/promises");
-const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
-class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
-    constructor(directory, chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds) {
-        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
-        this.directory = directory;
-    }
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    async getLastEventData() {
-        try {
-            const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
-            const arr = txt.split(",");
-            if (arr.length < 2) {
-                const blockNumber = parseInt(arr[0].split(";")[0]);
-                if (isNaN(blockNumber))
-                    throw new Error("Cannot parse the integer, is NaN!");
-                return [
-                    { lastBlockNumber: blockNumber },
-                    { lastBlockNumber: blockNumber }
-                ];
-            }
-            return arr.map(arrValue => {
-                const subArray = arrValue.split(";");
-                const lastBlockNumber = parseInt(subArray[0]);
-                if (isNaN(lastBlockNumber))
-                    throw new Error("Cannot parse the integer, is NaN!");
-                return { lastBlockNumber, lastTxHash: subArray[1] };
-            });
-        }
-        catch (e) {
-            return [];
-        }
-    }
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    saveLastEventData(newState) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, newState.map(value => value.lastTxHash == null ? value.lastBlockNumber.toString(10) : value.lastBlockNumber.toString(10) + ";" + value.lastTxHash).join(","));
-    }
-    async init(noAutomaticPoll) {
-        if (noAutomaticPoll)
-            return;
-        this.stopped = false;
-        const lastEventsState = await this.getLastEventData();
-        if (this.wsChannel != null)
-            await this.setupWebsocket();
-        await this.setupPoll(lastEventsState, (newState) => this.saveLastEventData(newState));
-    }
-}
-exports.StarknetChainEvents = StarknetChainEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetChainEvents = void 0;
+const StarknetChainEventsBrowser_1 = require("./StarknetChainEventsBrowser");
+//@ts-ignore
+const fs = require("fs/promises");
+const BLOCKHEIGHT_FILENAME = "/strk-blockheight.txt";
+class StarknetChainEvents extends StarknetChainEventsBrowser_1.StarknetChainEventsBrowser {
+    constructor(directory, chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds) {
+        super(chainInterface, starknetSwapContract, starknetSpvVaultContract, pollIntervalSeconds);
+        this.directory = directory;
+    }
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    async getLastEventData() {
+        try {
+            const txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
+            const arr = txt.split(",");
+            if (arr.length < 2) {
+                const blockNumber = parseInt(arr[0].split(";")[0]);
+                if (isNaN(blockNumber))
+                    throw new Error("Cannot parse the integer, is NaN!");
+                return [
+                    { lastBlockNumber: blockNumber },
+                    { lastBlockNumber: blockNumber }
+                ];
+            }
+            return arr.map(arrValue => {
+                const subArray = arrValue.split(";");
+                const lastBlockNumber = parseInt(subArray[0]);
+                if (isNaN(lastBlockNumber))
+                    throw new Error("Cannot parse the integer, is NaN!");
+                return { lastBlockNumber, lastTxHash: subArray[1] };
+            });
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(newState) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, newState.map(value => value.lastTxHash == null ? value.lastBlockNumber.toString(10) : value.lastBlockNumber.toString(10) + ";" + value.lastTxHash).join(","));
+    }
+    async init(noAutomaticPoll) {
+        if (noAutomaticPoll)
+            return;
+        this.stopped = false;
+        const lastEventsState = await this.getLastEventData();
+        if (this.wsChannel != null)
+            await this.setupWebsocket();
+        await this.setupPoll(lastEventsState, (newState) => this.saveLastEventData(newState));
+    }
+}
+exports.StarknetChainEvents = StarknetChainEvents;