@atomiqlabs/chain-evm 2.1.12 → 2.2.0

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

@@ -1,22 +1,40 @@
-import { BaseContract, Log, TransactionDescription } from "ethers";
+import { BaseContract, TransactionDescription } from "ethers";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMContractEvents } from "./modules/EVMContractEvents";
-import { TypedContractMethod, TypedEventLog } from "../typechain/common";
+import { TypedContractMethod } from "../typechain/common";
 type __TypechainOutputObject<T> = T extends TypedContractMethod<infer V> ? V : never;
+/**
+ * Typed transaction call decoded from calldata for a specific contract method.
+ *
+ * @category Internal/Contracts
+ */
 export interface TypedFunctionCall<TCMethod extends TypedContractMethod> extends Omit<TransactionDescription, "args"> {
     args: __TypechainOutputObject<TCMethod>;
 }
 /**
- * Base class providing program specific utilities
+ * Base contract wrapper providing typed event and calldata parsing helpers.
+ *
+ * @category Internal/Contracts
  */
 export declare class EVMContractBase<T extends BaseContract> {
-    contract: T;
-    readonly Events: EVMContractEvents<T>;
-    readonly Chain: EVMChainInterface<any>;
-    readonly contractAddress: string;
-    readonly contractDeploymentHeight?: number;
+    readonly contract: T;
+    /**
+     * @internal
+     */
+    readonly _Events: EVMContractEvents<T>;
+    protected readonly Chain: EVMChainInterface<any>;
+    /**
+     * @internal
+     */
+    readonly _contractAddress: string;
+    /**
+     * @internal
+     */
+    readonly _contractDeploymentHeight?: number;
     constructor(chainInterface: EVMChainInterface<any>, contractAddress: string, contractAbi: any, contractDeploymentHeight?: number);
-    toTypedEvent<TEventName extends keyof T["filters"] = keyof T["filters"]>(log: Log): TypedEventLog<T["filters"][TEventName]> | null;
-    parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod>;
+    /**
+     * @internal
+     */
+    protected parseCalldata<TMethod extends TypedContractMethod>(calldata: string): TypedFunctionCall<TMethod>;
 }
 export {};

package/dist/evm/contract/EVMContractBase.js

@@ -4,30 +4,21 @@ exports.EVMContractBase = void 0;
 const ethers_1 = require("ethers");
 const EVMContractEvents_1 = require("./modules/EVMContractEvents");
 /**
- * Base class providing program specific utilities
+ * Base contract wrapper providing typed event and calldata parsing helpers.
+ *
+ * @category Internal/Contracts
  */
 class EVMContractBase {
     constructor(chainInterface, contractAddress, contractAbi, contractDeploymentHeight) {
         this.Chain = chainInterface;
         this.contract = new ethers_1.Contract(contractAddress, contractAbi, chainInterface.provider);
-        this.Events = new EVMContractEvents_1.EVMContractEvents(chainInterface, this);
-        this.contractAddress = contractAddress;
-        this.contractDeploymentHeight = contractDeploymentHeight;
-    }
-    toTypedEvent(log) {
-        let foundFragment = null;
-        try {
-            foundFragment = this.contract.interface.getEvent(log.topics[0]);
-        }
-        catch (error) { }
-        if (!foundFragment)
-            return null;
-        try {
-            return new ethers_1.EventLog(log, this.contract.interface, foundFragment);
-        }
-        catch (error) { }
-        return null;
+        this._Events = new EVMContractEvents_1.EVMContractEvents(chainInterface, this);
+        this._contractAddress = contractAddress;
+        this._contractDeploymentHeight = contractDeploymentHeight;
     }
+    /**
+     * @internal
+     */
     parseCalldata(calldata) {
         return this.contract.interface.parseTransaction({ data: calldata });
     }

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

@@ -2,6 +2,11 @@ import { BaseContract } from "ethers";
 import { EVMModule } from "../chain/EVMModule";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMContractBase } from "./EVMContractBase";
+/**
+ * Base module class for EVM components tied to a specific contract wrapper.
+ *
+ * @category Internal/Contracts
+ */
 export declare class EVMContractModule<T extends BaseContract, C extends EVMContractBase<T> = EVMContractBase<T>> extends EVMModule<any> {
     readonly contract: C;
     constructor(chainInterface: EVMChainInterface<any>, contract: C);

package/dist/evm/contract/EVMContractModule.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMContractModule = void 0;
 const EVMModule_1 = require("../chain/EVMModule");
+/**
+ * Base module class for EVM components tied to a specific contract wrapper.
+ *
+ * @category Internal/Contracts
+ */
 class EVMContractModule extends EVMModule_1.EVMModule {
     constructor(chainInterface, contract) {
         super(chainInterface);

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

@@ -3,10 +3,16 @@ import { EVMEvents } from "../../chain/modules/EVMEvents";
 import { EVMContractBase } from "../EVMContractBase";
 import { EVMChainInterface } from "../../chain/EVMChainInterface";
 import { TypedEventLog } from "../../typechain/common";
+/**
+ * Typed contract event utilities built on top of generic EVM log querying helpers.
+ *
+ * @category Internal/Contracts
+ */
 export declare class EVMContractEvents<T extends BaseContract> extends EVMEvents {
-    readonly contract: EVMContractBase<T>;
+    private readonly contract;
     readonly baseContract: T;
     constructor(chainInterface: EVMChainInterface<any>, contract: EVMContractBase<T>);
+    private toTypedEvent;
     toTypedEvents<TEventName extends keyof T["filters"]>(blockEvents: Log[]): (TypedEventLog<T["filters"][TEventName]> | null)[];
     private toFilter;
     /**

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMContractEvents = void 0;
+const ethers_1 = require("ethers");
 const EVMEvents_1 = require("../../chain/modules/EVMEvents");
 function normalizeTopic(topic) {
     if (topic.length !== 66) {
@@ -8,14 +9,33 @@ function normalizeTopic(topic) {
     }
     return topic;
 }
+/**
+ * Typed contract event utilities built on top of generic EVM log querying helpers.
+ *
+ * @category Internal/Contracts
+ */
 class EVMContractEvents extends EVMEvents_1.EVMEvents {
     constructor(chainInterface, contract) {
         super(chainInterface);
         this.contract = contract;
         this.baseContract = contract.contract;
     }
+    toTypedEvent(log) {
+        let foundFragment = null;
+        try {
+            foundFragment = this.baseContract.interface.getEvent(log.topics[0]);
+        }
+        catch (error) { }
+        if (!foundFragment)
+            return null;
+        try {
+            return new ethers_1.EventLog(log, this.baseContract.interface, foundFragment);
+        }
+        catch (error) { }
+        return null;
+    }
     toTypedEvents(blockEvents) {
-        return blockEvents.map(log => this.contract.toTypedEvent(log));
+        return blockEvents.map(log => this.toTypedEvent(log));
     }
     toFilter(events, keys) {
         const filterArray = [];
@@ -61,7 +81,7 @@ class EVMContractEvents extends EVMEvents_1.EVMEvents {
                     return result;
             }
             return null;
-        }, abortSignal, this.contract.contractDeploymentHeight);
+        }, abortSignal, this.contract._contractDeploymentHeight);
     }
     /**
      * Runs a search forwards in time, processing the events for a specific topic
@@ -84,7 +104,7 @@ class EVMContractEvents extends EVMEvents_1.EVMEvents {
                     return result;
             }
             return null;
-        }, abortSignal, Math.max(this.contract.contractDeploymentHeight ?? 0, startHeight ?? 0));
+        }, abortSignal, Math.max(this.contract._contractDeploymentHeight ?? 0, startHeight ?? 0));
     }
 }
 exports.EVMContractEvents = EVMContractEvents;

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

@@ -2,6 +2,11 @@ import { EVMChainEventsBrowser } from "./EVMChainEventsBrowser";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMSwapContract } from "../swaps/EVMSwapContract";
 import { EVMSpvVaultContract } from "../spv_swap/EVMSpvVaultContract";
+/**
+ * Backend event listener with persisted polling cursor stored on filesystem.
+ *
+ * @category Events
+ */
 export declare class EVMChainEvents extends EVMChainEventsBrowser {
     private readonly directory;
     private readonly BLOCKHEIGHT_FILENAME;
@@ -18,5 +23,8 @@ export declare class EVMChainEvents extends EVMChainEventsBrowser {
      * @private
      */
     private saveLastEventData;
+    /**
+     * @inheritDoc
+     */
     init(noAutomaticPoll?: boolean): Promise<void>;
 }

package/dist/evm/events/EVMChainEvents.js

@@ -4,6 +4,11 @@ exports.EVMChainEvents = void 0;
 //@ts-ignore
 const fs = require("fs/promises");
 const EVMChainEventsBrowser_1 = require("./EVMChainEventsBrowser");
+/**
+ * Backend event listener with persisted polling cursor stored on filesystem.
+ *
+ * @category Events
+ */
 class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
     constructor(directory, chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds) {
         super(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds);
@@ -70,6 +75,9 @@ class EVMChainEvents extends EVMChainEventsBrowser_1.EVMChainEventsBrowser {
             }
         }).join(";"));
     }
+    /**
+     * @inheritDoc
+     */
     async init(noAutomaticPoll) {
         if (noAutomaticPoll)
             return Promise.resolve();

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

@@ -1,4 +1,4 @@
-import { ChainEvents, ClaimEvent, EventListener, InitializeEvent, RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent } from "@atomiqlabs/base";
+import { ChainEvents, EventListener } from "@atomiqlabs/base";
 import { EVMSwapData } from "../swaps/EVMSwapData";
 import { Block, JsonRpcApiProvider, EventFilter, Log } from "ethers";
 import { EVMSwapContract } from "../swaps/EVMSwapContract";
@@ -7,6 +7,12 @@ import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { TypedEventLog } from "../typechain/common";
 import { EscrowManager } from "../swaps/EscrowManagerTypechain";
 import { SpvVaultManager } from "../spv_swap/SpvVaultContractTypechain";
+/**
+ * Current state of the EVM event listener, containing the last processed block number
+ *  and event position.
+ *
+ * @category Events
+ */
 export type EVMEventListenerState = {
     lastBlockNumber: number;
     lastEvent?: {
@@ -19,23 +25,61 @@ type AtomiqTypedEvent = (TypedEventLog<EscrowManager["filters"]["Initialize" | "
  * EVM 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
+ *
+ * @category Events
  */
 export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, EVMEventListenerState[]> {
     private eventsProcessing;
     private processedEvents;
     private processedEventsIndex;
+    /**
+     * @internal
+     */
     protected readonly listeners: EventListener<EVMSwapData>[];
+    /**
+     * @internal
+     */
     protected readonly provider: JsonRpcApiProvider;
+    /**
+     * @internal
+     */
     protected readonly chainInterface: EVMChainInterface;
+    /**
+     * @internal
+     */
     protected readonly evmSwapContract: EVMSwapContract;
+    /**
+     * @internal
+     */
     protected readonly evmSpvVaultContract: EVMSpvVaultContract<any>;
+    /**
+     * @internal
+     */
     protected readonly logger: import("../../utils/Utils").LoggerType;
+    /**
+     * @internal
+     */
     protected stopped: boolean;
+    /**
+     * @internal
+     */
     protected pollIntervalSeconds: number;
     private timeout?;
+    /**
+     * @internal
+     */
     protected readonly spvVaultContractLogFilter: EventFilter;
+    /**
+     * @internal
+     */
     protected readonly swapContractLogFilter: EventFilter;
+    /**
+     * @internal
+     */
     protected unconfirmedEventQueue: AtomiqTypedEvent[];
+    /**
+     * @internal
+     */
     protected confirmedEventQueue: {
         event: AtomiqTypedEvent;
         block: Block;
@@ -52,14 +96,14 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, E
      * @returns {() => Promise<EVMSwapData | null>} getter to be passed to InitializeEvent constructor
      */
     private getSwapDataGetter;
-    protected parseInitializeEvent(event: TypedEventLog<EscrowManager["filters"]["Initialize"]>): InitializeEvent<EVMSwapData> | null;
-    protected parseRefundEvent(event: TypedEventLog<EscrowManager["filters"]["Refund"]>): RefundEvent<EVMSwapData>;
-    protected parseClaimEvent(event: TypedEventLog<EscrowManager["filters"]["Claim"]>): ClaimEvent<EVMSwapData> | null;
-    protected parseSpvOpenEvent(event: TypedEventLog<SpvVaultManager["filters"]["Opened"]>): SpvVaultOpenEvent;
-    protected parseSpvDepositEvent(event: TypedEventLog<SpvVaultManager["filters"]["Deposited"]>): SpvVaultDepositEvent;
-    protected parseSpvFrontEvent(event: TypedEventLog<SpvVaultManager["filters"]["Fronted"]>): SpvVaultFrontEvent;
-    protected parseSpvClaimEvent(event: TypedEventLog<SpvVaultManager["filters"]["Claimed"]>): SpvVaultClaimEvent;
-    protected parseSpvCloseEvent(event: TypedEventLog<SpvVaultManager["filters"]["Closed"]>): SpvVaultCloseEvent;
+    private parseInitializeEvent;
+    private parseRefundEvent;
+    private parseClaimEvent;
+    private parseSpvOpenEvent;
+    private parseSpvDepositEvent;
+    private parseSpvFrontEvent;
+    private parseSpvClaimEvent;
+    private parseSpvCloseEvent;
     /**
      * Processes event as received from the chain, parses it & calls event listeners
      *
@@ -67,15 +111,9 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, E
      * @param currentBlock
      * @protected
      */
-    protected processEvents(events: (TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> | TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>)[], currentBlock?: Block): Promise<void>;
-    protected checkEventsEcrowManager(currentBlock: Block, lastEvent?: {
-        blockHash: string;
-        logIndex: number;
-    }, lastBlockNumber?: number): Promise<EVMEventListenerState>;
-    protected checkEventsSpvVaults(currentBlock: Block, lastEvent?: {
-        blockHash: string;
-        logIndex: number;
-    }, lastBlockNumber?: number): Promise<EVMEventListenerState>;
+    private processEvents;
+    private checkEventsEcrowManager;
+    private checkEventsSpvVaults;
     /**
      * @inheritDoc
      */
@@ -83,18 +121,48 @@ export declare class EVMChainEventsBrowser implements ChainEvents<EVMSwapData, E
     /**
      * Sets up event handlers listening for swap events over websocket
      *
-     * @protected
+     * @internal
      */
     protected setupPoll(lastState?: EVMEventListenerState[], saveLatestProcessedBlockNumber?: (newState: EVMEventListenerState[]) => Promise<void>): Promise<void>;
+    /**
+     * @internal
+     */
     protected handleWsEvent(event: AtomiqTypedEvent): Promise<void>;
+    /**
+     * @internal
+     */
     protected spvVaultContractListener?: (log: Log) => void;
+    /**
+     * @internal
+     */
     protected swapContractListener?: (log: Log) => void;
+    /**
+     * @internal
+     */
     protected blockListener?: (blockNumber: number) => Promise<void>;
+    /**
+     * @internal
+     */
     protected finalityCheckTimer: any;
+    /**
+     * @internal
+     */
     protected wsStarted: boolean;
+    /**
+     * @internal
+     */
     protected checkUnconfirmedEventsFinality(): Promise<void>;
+    /**
+     * @internal
+     */
     protected addOrRemoveBlockListener(): Promise<void>;
+    /**
+     * @internal
+     */
     protected startFinalityCheckTimer(): Promise<void>;
+    /**
+     * @internal
+     */
     protected setupWebsocket(): Promise<void>;
     /**
      * @inheritDoc

package/dist/evm/events/EVMChainEventsBrowser.js

@@ -10,17 +10,37 @@ const PROCESSED_EVENTS_BACKLOG = 1000;
  * EVM 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
+ *
+ * @category Events
  */
 class EVMChainEventsBrowser {
     constructor(chainInterface, evmSwapContract, evmSpvVaultContract, pollIntervalSeconds = 5) {
         this.eventsProcessing = {};
         this.processedEvents = [];
         this.processedEventsIndex = 0;
+        /**
+         * @internal
+         */
         this.listeners = [];
+        /**
+         * @internal
+         */
         this.logger = (0, Utils_1.getLogger)("EVMChainEventsBrowser: ");
+        /**
+         * @internal
+         */
         this.stopped = true;
+        /**
+         * @internal
+         */
         this.unconfirmedEventQueue = [];
+        /**
+         * @internal
+         */
         this.confirmedEventQueue = [];
+        /**
+         * @internal
+         */
         this.wsStarted = false;
         this.chainInterface = chainInterface;
         this.provider = chainInterface.provider;
@@ -28,10 +48,10 @@ class EVMChainEventsBrowser {
         this.evmSpvVaultContract = evmSpvVaultContract;
         this.pollIntervalSeconds = pollIntervalSeconds;
         this.spvVaultContractLogFilter = {
-            address: this.evmSpvVaultContract.contractAddress
+            address: this.evmSpvVaultContract._contractAddress
         };
         this.swapContractLogFilter = {
-            address: this.evmSwapContract.contractAddress
+            address: this.evmSwapContract._contractAddress
         };
     }
     addProcessedEvent(event) {
@@ -62,7 +82,7 @@ class EVMChainEventsBrowser {
     parseInitializeEvent(event) {
         const escrowHash = event.args.escrowHash.substring(2);
         const claimHandlerHex = event.args.claimHandler;
-        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
+        const claimHandler = this.evmSwapContract._claimHandlersByAddress[claimHandlerHex.toLowerCase()];
         if (claimHandler == null) {
             this.logger.warn("parseInitializeEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
             return null;
@@ -79,7 +99,7 @@ class EVMChainEventsBrowser {
     parseClaimEvent(event) {
         const escrowHash = event.args.escrowHash.substring(2);
         const claimHandlerHex = event.args.claimHandler;
-        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
+        const claimHandler = this.evmSwapContract._claimHandlersByAddress[claimHandlerHex.toLowerCase()];
         if (claimHandler == null) {
             this.logger.warn("parseClaimEvent(" + escrowHash + "): Unknown claim handler with claim: " + claimHandlerHex);
             return null;
@@ -210,7 +230,7 @@ class EVMChainEventsBrowser {
             return { lastEvent, lastBlockNumber };
         }
         // this.logger.debug(`checkEvents(EscrowManager): Requesting logs: ${lastBlockNumber}...${currentBlock.number}`);
-        let events = await this.evmSwapContract.Events.getContractBlockEvents(["Initialize", "Claim", "Refund"], [], lastBlockNumber, currentBlock.number);
+        let events = await this.evmSwapContract._Events.getContractBlockEvents(["Initialize", "Claim", "Refund"], [], lastBlockNumber, currentBlock.number);
         if (lastEvent != null) {
             const latestProcessedEventIndex = events.findIndex(val => val.blockHash === lastEvent.blockHash && val.index === lastEvent.logIndex);
             if (latestProcessedEventIndex !== -1) {
@@ -241,7 +261,7 @@ class EVMChainEventsBrowser {
             return { lastEvent, lastBlockNumber };
         }
         // this.logger.debug(`checkEvents(SpvVaults): Requesting logs: ${lastBlockNumber}...${currentBlock.number}`);
-        let events = await this.evmSpvVaultContract.Events.getContractBlockEvents(["Opened", "Deposited", "Closed", "Fronted", "Claimed"], [], lastBlockNumber, currentBlock.number);
+        let events = await this.evmSpvVaultContract._Events.getContractBlockEvents(["Opened", "Deposited", "Closed", "Fronted", "Claimed"], [], lastBlockNumber, currentBlock.number);
         if (lastEvent != null) {
             const latestProcessedEventIndex = events.findIndex(val => val.blockHash === lastEvent.blockHash && val.index === lastEvent.logIndex);
             if (latestProcessedEventIndex !== -1) {
@@ -270,9 +290,9 @@ class EVMChainEventsBrowser {
      */
     async poll(lastState) {
         lastState ?? (lastState = []);
-        const currentBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag, false);
+        const currentBlock = await this.provider.getBlock(this.chainInterface._config.safeBlockTag, false);
         if (currentBlock == null)
-            throw new Error(`Cannot fetch '${this.chainInterface.config.safeBlockTag}' block!`);
+            throw new Error(`Cannot fetch '${this.chainInterface._config.safeBlockTag}' block!`);
         const resultEscrow = await this.checkEventsEcrowManager(currentBlock, lastState?.[0]?.lastEvent, lastState?.[0]?.lastBlockNumber);
         const resultSpvVault = await this.checkEventsSpvVaults(currentBlock, lastState?.[1]?.lastEvent, lastState?.[1]?.lastBlockNumber);
         lastState = [
@@ -284,7 +304,7 @@ class EVMChainEventsBrowser {
     /**
      * Sets up event handlers listening for swap events over websocket
      *
-     * @protected
+     * @internal
      */
     async setupPoll(lastState, saveLatestProcessedBlockNumber) {
         this.stopped = false;
@@ -304,18 +324,24 @@ class EVMChainEventsBrowser {
         await func();
     }
     //Websocket
+    /**
+     * @internal
+     */
     handleWsEvent(event) {
-        if (this.chainInterface.config.safeBlockTag === "latest" || this.chainInterface.config.safeBlockTag === "pending") {
+        if (this.chainInterface._config.safeBlockTag === "latest" || this.chainInterface._config.safeBlockTag === "pending") {
             return this.processEvents([event]);
         }
         this.unconfirmedEventQueue.push(event);
         return this.addOrRemoveBlockListener();
     }
+    /**
+     * @internal
+     */
     async checkUnconfirmedEventsFinality() {
         if (this.unconfirmedEventQueue.length > 0) {
-            const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
+            const latestSafeBlock = await this.provider.getBlock(this.chainInterface._config.safeBlockTag);
             if (latestSafeBlock == null)
-                throw new Error(`Failed to fetch '${this.chainInterface.config.safeBlockTag}' block!`);
+                throw new Error(`Failed to fetch '${this.chainInterface._config.safeBlockTag}' block!`);
             const events = this.unconfirmedEventQueue.filter(event => {
                 return event.blockNumber <= latestSafeBlock.number;
             });
@@ -340,8 +366,11 @@ class EVMChainEventsBrowser {
                 this.confirmedEventQueue.splice(index, 1);
         }
     }
+    /**
+     * @internal
+     */
     async addOrRemoveBlockListener() {
-        if (this.chainInterface.config.finalityCheckStrategy?.type !== "blocks")
+        if (this.chainInterface._config.finalityCheckStrategy?.type !== "blocks")
             return;
         if (this.unconfirmedEventQueue.length > 0 || this.confirmedEventQueue.length > 0) {
             this.logger.debug(`addOrRemoveBlockListener(): Adding block listener, unconfirmed/confirmed event count: ${this.unconfirmedEventQueue.length + this.confirmedEventQueue.length}`);
@@ -352,6 +381,9 @@ class EVMChainEventsBrowser {
             await this.provider.off("block", this.blockListener);
         }
     }
+    /**
+     * @internal
+     */
     async startFinalityCheckTimer() {
         let check;
         check = async () => {
@@ -367,10 +399,13 @@ class EVMChainEventsBrowser {
             }
             if (!this.wsStarted)
                 return;
-            this.finalityCheckTimer = setTimeout(check, this.chainInterface.config.finalityCheckStrategy?.delayMs ?? 5 * 1000);
+            this.finalityCheckTimer = setTimeout(check, this.chainInterface._config.finalityCheckStrategy?.delayMs ?? 5 * 1000);
         };
         await check();
     }
+    /**
+     * @internal
+     */
     async setupWebsocket() {
         this.wsStarted = true;
         let processing = false;
@@ -389,18 +424,18 @@ class EVMChainEventsBrowser {
             processing = false;
             await this.addOrRemoveBlockListener();
         };
-        if (this.chainInterface.config.safeBlockTag === "safe" || this.chainInterface.config.safeBlockTag === "finalized") {
-            if (this.chainInterface.config.finalityCheckStrategy?.type === "timer")
+        if (this.chainInterface._config.safeBlockTag === "safe" || this.chainInterface._config.safeBlockTag === "finalized") {
+            if (this.chainInterface._config.finalityCheckStrategy?.type === "timer")
                 this.startFinalityCheckTimer();
         }
         await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
-            let [event] = this.evmSpvVaultContract.Events.toTypedEvents([log]);
+            let [event] = this.evmSpvVaultContract._Events.toTypedEvents([log]);
             if (event == null || event.removed)
                 return;
             this.handleWsEvent(event);
         });
         await this.provider.on(this.swapContractLogFilter, this.swapContractListener = (log) => {
-            let [event] = this.evmSwapContract.Events.toTypedEvents([log]);
+            let [event] = this.evmSwapContract._Events.toTypedEvents([log]);
             if (event == null || event.removed)
                 return;
             if (event.eventName !== "Initialize" && event.eventName !== "Refund" && event.eventName !== "Claim")

package/dist/evm/providers/JsonRpcProviderWithRetries.d.ts

@@ -1,6 +1,8 @@
 import { JsonRpcProvider, JsonRpcApiProviderOptions } from "ethers";
 import { Networkish, FetchRequest } from "ethers";
 /**
+ * JSON-RPC provider with built-in retry functionality for transient RPC failures.
+ *
  * @category Providers
  */
 export declare class JsonRpcProviderWithRetries extends JsonRpcProvider {
@@ -9,6 +11,13 @@ export declare class JsonRpcProviderWithRetries extends JsonRpcProvider {
         delay?: number;
         exponential?: boolean;
     };
+    /**
+     * Creates a new JSON-RPC provider which retries RPC calls based on the provided policy.
+     *
+     * @param url
+     * @param network
+     * @param options
+     */
     constructor(url: string | FetchRequest, network?: Networkish, options?: JsonRpcApiProviderOptions & {
         maxRetries?: number;
         delay?: number;

package/dist/evm/providers/JsonRpcProviderWithRetries.js

@@ -5,9 +5,18 @@ const ethers_1 = require("ethers");
 const ethers_2 = require("ethers");
 const Utils_1 = require("../../utils/Utils");
 /**
+ * JSON-RPC provider with built-in retry functionality for transient RPC failures.
+ *
  * @category Providers
  */
 class JsonRpcProviderWithRetries extends ethers_1.JsonRpcProvider {
+    /**
+     * Creates a new JSON-RPC provider which retries RPC calls based on the provided policy.
+     *
+     * @param url
+     * @param network
+     * @param options
+     */
     constructor(url, network, options) {
         if (typeof (url) === "string")
             url = new ethers_2.FetchRequest(url);

package/dist/evm/providers/ReconnectingWebSocketProvider.d.ts

@@ -1,6 +1,11 @@
 import { JsonRpcApiProviderOptions } from "ethers";
 import type { Networkish, WebSocketLike } from "ethers";
 import { SocketProvider } from "./SocketProvider";
+/**
+ * WebSocket RPC provider with automatic reconnect, heartbeat ping and connection timeout handling.
+ *
+ * @category Providers
+ */
 export declare class ReconnectingWebSocketProvider extends SocketProvider {
     requestTimeoutSeconds: number;
     reconnectSeconds: number;