@atomiqlabs/chain-starknet 3.0.0-dev.8 → 4.0.0-dev.3

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

@@ -1,51 +1,51 @@
-import { Abi } from "abi-wan-kanabi";
-import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
-import { 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 {
-    readonly contract: StarknetContractBase<TAbi>;
-    readonly abi: TAbi;
-    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
-    private toStarknetAbiEvents;
-    private toFilter;
-    /**
-     * 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: string[], startBlockHeight?: number, endBlockHeight?: number): 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: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
-    /**
-     * 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 abortSignal
-     */
-    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
-}
+import { Abi } from "abi-wan-kanabi";
+import { EventToPrimitiveType, ExtractAbiEventNames } from "abi-wan-kanabi/dist/kanabi";
+import { 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 {
+    readonly contract: StarknetContractBase<TAbi>;
+    readonly abi: TAbi;
+    constructor(chainInterface: StarknetChainInterface, contract: StarknetContractBase<TAbi>, abi: TAbi);
+    private toStarknetAbiEvents;
+    private toFilter;
+    /**
+     * 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: string[], startBlockHeight?: number, endBlockHeight?: number): 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: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+    /**
+     * 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 abortSignal
+     */
+    findInContractEventsForward<T, TEvent extends ExtractAbiEventNames<TAbi>>(events: TEvent[], keys: string[], processor: (event: StarknetAbiEvent<TAbi, TEvent>) => Promise<T>, abortSignal?: AbortSignal): Promise<T>;
+}

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

@@ -1,97 +1,97 @@
-"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;
-    }
-    toStarknetAbiEvents(blockEvents) {
-        const abiEvents = starknet_1.events.getAbiEvents(this.abi);
-        const abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
-        const abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
-        const result = starknet_1.events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums);
-        if (result.length !== blockEvents.length)
-            throw new Error("Invalid event detected, please check provided ABI");
-        return result.map((value, index) => {
-            const starknetEvent = blockEvents[index];
-            const name = Object.keys(value)[0];
-            return {
-                name: name,
-                txHash: starknetEvent.transaction_hash,
-                params: value[name],
-                blockNumber: starknetEvent.block_number,
-                blockHash: starknetEvent.block_hash,
-                data: starknetEvent.data,
-                keys: starknetEvent.keys
-            };
-        });
-    }
-    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));
-        }));
-        if (keys != null)
-            keys.forEach(key => filterArray.push(key == null ? [] : [key]));
-        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 = 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;
-            }
-        }, 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 abortSignal
-     */
-    async findInContractEventsForward(events, keys, processor, 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;
-            }
-        }, 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;
+    }
+    toStarknetAbiEvents(blockEvents) {
+        const abiEvents = starknet_1.events.getAbiEvents(this.abi);
+        const abiStructs = starknet_1.CallData.getAbiStruct(this.abi);
+        const abiEnums = starknet_1.CallData.getAbiEnum(this.abi);
+        const result = starknet_1.events.parseEvents(blockEvents, abiEvents, abiStructs, abiEnums);
+        if (result.length !== blockEvents.length)
+            throw new Error("Invalid event detected, please check provided ABI");
+        return result.map((value, index) => {
+            const starknetEvent = blockEvents[index];
+            const name = Object.keys(value)[0];
+            return {
+                name: name,
+                txHash: starknetEvent.transaction_hash,
+                params: value[name],
+                blockNumber: starknetEvent.block_number,
+                blockHash: starknetEvent.block_hash,
+                data: starknetEvent.data,
+                keys: starknetEvent.keys
+            };
+        });
+    }
+    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));
+        }));
+        if (keys != null)
+            keys.forEach(key => filterArray.push(key == null ? [] : [key]));
+        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 = 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;
+            }
+        }, 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 abortSignal
+     */
+    async findInContractEventsForward(events, keys, processor, 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;
+            }
+        }, 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(): 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(): Promise<void>;
+}

package/dist/starknet/events/StarknetChainEvents.js

@@ -1,52 +1,52 @@
-"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)
-                return {
-                    blockNumber: parseInt(arr[0]),
-                    txHashes: null
-                };
-            return {
-                blockNumber: parseInt(arr[0]),
-                txHashes: arr.slice(1)
-            };
-        }
-        catch (e) {
-            return {
-                blockNumber: null,
-                txHashes: null
-            };
-        }
-    }
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    saveLastEventData(blockNumber, txHashes) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
-    }
-    async init() {
-        const { blockNumber, txHashes } = await this.getLastEventData();
-        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
-    }
-}
-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)
+                return {
+                    blockNumber: parseInt(arr[0]),
+                    txHashes: null
+                };
+            return {
+                blockNumber: parseInt(arr[0]),
+                txHashes: arr.slice(1)
+            };
+        }
+        catch (e) {
+            return {
+                blockNumber: null,
+                txHashes: null
+            };
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastEventData(blockNumber, txHashes) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, blockNumber.toString() + ";" + txHashes.join(";"));
+    }
+    async init() {
+        const { blockNumber, txHashes } = await this.getLastEventData();
+        await this.setupPoll(blockNumber, txHashes, (blockNumber, txHashes) => this.saveLastEventData(blockNumber, txHashes));
+    }
+}
+exports.StarknetChainEvents = StarknetChainEvents;

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

@@ -1,91 +1,90 @@
-import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent } from "@atomiqlabs/base";
-import { StarknetSwapData } from "../swaps/StarknetSwapData";
-import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
-import { BigNumberish, Provider } from "starknet";
-import { StarknetAbiEvent } from "../contract/modules/StarknetContractEvents";
-import { EscrowManagerAbiType } from "../swaps/EscrowManagerAbi";
-import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
-import { IClaimHandler } from "../swaps/handlers/claim/ClaimHandlers";
-import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
-import { StarknetChainInterface } from "../chain/StarknetChainInterface";
-import { SpvVaultContractAbiType } from "../spv_swap/SpvVaultContractAbi";
-export type StarknetTraceCall = {
-    calldata: string[];
-    contract_address: string;
-    entry_point_selector: string;
-    calls: StarknetTraceCall[];
-};
-/**
- * Solana on-chain event handler for front-end systems without access to fs, uses pure WS to subscribe, might lose
- *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
- *  rely purely on events
- */
-export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData> {
-    protected readonly listeners: EventListener<StarknetSwapData>[];
-    protected readonly provider: Provider;
-    protected readonly starknetSwapContract: StarknetSwapContract;
-    protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
-    protected eventListeners: number[];
-    protected readonly logger: {
-        debug: (msg: any, ...args: any[]) => void;
-        info: (msg: any, ...args: any[]) => void;
-        warn: (msg: any, ...args: any[]) => void;
-        error: (msg: any, ...args: any[]) => void;
-    };
-    protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
-    protected initEntryPointSelector: bigint;
-    protected stopped: boolean;
-    protected pollIntervalSeconds: number;
-    private timeout;
-    constructor(chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
-    findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData;
-    /**
-     * Returns async getter for fetching on-demand initialize event swap data
-     *
-     * @param event
-     * @param claimHandler
-     * @private
-     * @returns {() => Promise<StarknetSwapData>} getter to be passed to InitializeEvent constructor
-     */
-    private getSwapDataGetter;
-    protected parseInitializeEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize">): InitializeEvent<StarknetSwapData>;
-    protected parseRefundEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Refund">): RefundEvent<StarknetSwapData>;
-    protected parseClaimEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Claim">): ClaimEvent<StarknetSwapData>;
-    protected parseSpvOpenEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened">): SpvVaultOpenEvent;
-    protected parseSpvDepositEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Deposited">): SpvVaultDepositEvent;
-    protected parseSpvFrontEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Fronted">): SpvVaultFrontEvent;
-    protected parseSpvClaimEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Claimed">): SpvVaultClaimEvent;
-    protected parseSpvCloseEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Closed">): SpvVaultCloseEvent;
-    /**
-     * Processes event as received from the chain, parses it & calls event listeners
-     *
-     * @param events
-     * @param currentBlockNumber
-     * @param currentBlockTimestamp
-     * @param pendingEventTime
-     * @protected
-     */
-    protected processEvents(events: (StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim"> | StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed">)[], currentBlockNumber: number, currentBlockTimestamp: number, pendingEventTime: number): Promise<void>;
-    protected checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
-        timestamp: number;
-        block_number: number;
-    }): Promise<string>;
-    protected checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
-        timestamp: number;
-        block_number: number;
-    }): Promise<string>;
-    protected checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{
-        txHashes: string[];
-        blockNumber: number;
-    }>;
-    /**
-     * Sets up event handlers listening for swap events over websocket
-     *
-     * @protected
-     */
-    protected setupPoll(lastBlockNumber?: number, lastTxHashes?: string[], saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>): Promise<void>;
-    init(): Promise<void>;
-    stop(): Promise<void>;
-    registerListener(cbk: EventListener<StarknetSwapData>): void;
-    unregisterListener(cbk: EventListener<StarknetSwapData>): boolean;
-}
+import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent } from "@atomiqlabs/base";
+import { StarknetSwapData } from "../swaps/StarknetSwapData";
+import { StarknetSwapContract } from "../swaps/StarknetSwapContract";
+import { BigNumberish, Provider } from "starknet";
+import { StarknetAbiEvent } from "../contract/modules/StarknetContractEvents";
+import { EscrowManagerAbiType } from "../swaps/EscrowManagerAbi";
+import { ExtractAbiFunctionNames } from "abi-wan-kanabi/dist/kanabi";
+import { IClaimHandler } from "../swaps/handlers/claim/ClaimHandlers";
+import { StarknetSpvVaultContract } from "../spv_swap/StarknetSpvVaultContract";
+import { StarknetChainInterface } from "../chain/StarknetChainInterface";
+import { SpvVaultContractAbiType } from "../spv_swap/SpvVaultContractAbi";
+export type StarknetTraceCall = {
+    calldata: string[];
+    contract_address: string;
+    entry_point_selector: string;
+    calls: StarknetTraceCall[];
+};
+/**
+ * Starknet on-chain event handler for front-end systems without access to fs, uses WS or long-polling to subscribe, might lose
+ *  out on some events if the network is unreliable, front-end systems should take this into consideration and not
+ *  rely purely on events
+ */
+export declare class StarknetChainEventsBrowser implements ChainEvents<StarknetSwapData> {
+    protected readonly listeners: EventListener<StarknetSwapData>[];
+    protected readonly provider: Provider;
+    protected readonly starknetSwapContract: StarknetSwapContract;
+    protected readonly starknetSpvVaultContract: StarknetSpvVaultContract;
+    protected readonly logger: {
+        debug: (msg: any, ...args: any[]) => void;
+        info: (msg: any, ...args: any[]) => void;
+        warn: (msg: any, ...args: any[]) => void;
+        error: (msg: any, ...args: any[]) => void;
+    };
+    protected initFunctionName: ExtractAbiFunctionNames<EscrowManagerAbiType>;
+    protected initEntryPointSelector: bigint;
+    protected stopped: boolean;
+    protected pollIntervalSeconds: number;
+    private timeout;
+    constructor(chainInterface: StarknetChainInterface, starknetSwapContract: StarknetSwapContract, starknetSpvVaultContract: StarknetSpvVaultContract, pollIntervalSeconds?: number);
+    findInitSwapData(call: StarknetTraceCall, escrowHash: BigNumberish, claimHandler: IClaimHandler<any, any>): StarknetSwapData;
+    /**
+     * Returns async getter for fetching on-demand initialize event swap data
+     *
+     * @param event
+     * @param claimHandler
+     * @private
+     * @returns {() => Promise<StarknetSwapData>} getter to be passed to InitializeEvent constructor
+     */
+    private getSwapDataGetter;
+    protected parseInitializeEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize">): InitializeEvent<StarknetSwapData>;
+    protected parseRefundEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Refund">): RefundEvent<StarknetSwapData>;
+    protected parseClaimEvent(event: StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Claim">): ClaimEvent<StarknetSwapData>;
+    protected parseSpvOpenEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened">): SpvVaultOpenEvent;
+    protected parseSpvDepositEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Deposited">): SpvVaultDepositEvent;
+    protected parseSpvFrontEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Fronted">): SpvVaultFrontEvent;
+    protected parseSpvClaimEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Claimed">): SpvVaultClaimEvent;
+    protected parseSpvCloseEvent(event: StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Closed">): SpvVaultCloseEvent;
+    /**
+     * Processes event as received from the chain, parses it & calls event listeners
+     *
+     * @param events
+     * @param currentBlockNumber
+     * @param currentBlockTimestamp
+     * @param pendingEventTime
+     * @protected
+     */
+    protected processEvents(events: (StarknetAbiEvent<EscrowManagerAbiType, "escrow_manager::events::Initialize" | "escrow_manager::events::Refund" | "escrow_manager::events::Claim"> | StarknetAbiEvent<SpvVaultContractAbiType, "spv_swap_vault::events::Opened" | "spv_swap_vault::events::Deposited" | "spv_swap_vault::events::Fronted" | "spv_swap_vault::events::Claimed" | "spv_swap_vault::events::Closed">)[], currentBlockNumber: number, currentBlockTimestamp: number, pendingEventTime: number): Promise<void>;
+    protected checkEventsEcrowManager(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+        timestamp: number;
+        block_number: number;
+    }): Promise<string>;
+    protected checkEventsSpvVaults(lastTxHash: string, lastBlockNumber?: number, currentBlock?: {
+        timestamp: number;
+        block_number: number;
+    }): Promise<string>;
+    protected checkEvents(lastBlockNumber: number, lastTxHashes: string[]): Promise<{
+        txHashes: string[];
+        blockNumber: number;
+    }>;
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @protected
+     */
+    protected setupPoll(lastBlockNumber?: number, lastTxHashes?: string[], saveLatestProcessedBlockNumber?: (blockNumber: number, lastTxHashes: string[]) => Promise<void>): Promise<void>;
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    registerListener(cbk: EventListener<StarknetSwapData>): void;
+    unregisterListener(cbk: EventListener<StarknetSwapData>): boolean;
+}