@atomiqlabs/chain-evm 1.0.0-dev.100

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -0,0 +1,533 @@
+import {
+    ChainEvent,
+    ChainEvents,
+    ChainSwapType,
+    ClaimEvent,
+    EventListener,
+    InitializeEvent,
+    RefundEvent, SpvVaultClaimEvent, SpvVaultCloseEvent, SpvVaultDepositEvent, SpvVaultFrontEvent, SpvVaultOpenEvent
+} from "@atomiqlabs/base";
+import {IClaimHandler} from "../swaps/handlers/claim/ClaimHandlers";
+import {EVMSwapData} from "../swaps/EVMSwapData";
+import {Block, hexlify, JsonRpcApiProvider, EventFilter, Log} from "ethers";
+import { EVMSwapContract } from "../swaps/EVMSwapContract";
+import {getLogger, onceAsync} from "../../utils/Utils";
+import {EVMSpvVaultContract, unpackOwnerAndVaultId} from "../spv_swap/EVMSpvVaultContract";
+import { EVMChainInterface } from "../chain/EVMChainInterface";
+import {TypedEventLog} from "../typechain/common";
+import {EscrowManager} from "../swaps/EscrowManagerTypechain";
+import {SpvVaultManager} from "../spv_swap/SpvVaultContractTypechain";
+import {EVMTxTrace} from "../chain/modules/EVMTransactions";
+
+const LOGS_SLIDING_WINDOW_LENGTH = 60;
+
+const PROCESSED_EVENTS_BACKLOG = 1000;
+
+export type EVMEventListenerState = {lastBlockNumber: number, lastEvent?: {blockHash: string, logIndex: number}};
+
+type AtomiqTypedEvent = (
+    TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> |
+    TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>
+);
+
+/**
+ * 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
+ */
+export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
+
+    private eventsProcessing: {
+        [signature: string]: Promise<void>
+    } = {};
+    private processedEvents: string[] = [];
+    private processedEventsIndex: number = 0;
+
+    protected readonly listeners: EventListener<EVMSwapData>[] = [];
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly chainInterface: EVMChainInterface;
+    protected readonly evmSwapContract: EVMSwapContract;
+    protected readonly evmSpvVaultContract: EVMSpvVaultContract<any>;
+    protected readonly logger = getLogger("EVMChainEventsBrowser: ");
+
+    protected stopped: boolean;
+    protected pollIntervalSeconds: number;
+
+    private timeout: number;
+
+    //Websocket
+    protected readonly spvVaultContractLogFilter: EventFilter;
+    protected readonly swapContractLogFilter: EventFilter;
+
+    protected unconfirmedEventQueue: AtomiqTypedEvent[] = [];
+
+    constructor(
+        chainInterface: EVMChainInterface,
+        evmSwapContract: EVMSwapContract,
+        evmSpvVaultContract: EVMSpvVaultContract<any>,
+        pollIntervalSeconds: number = 5
+    ) {
+        this.chainInterface = chainInterface;
+        this.provider = chainInterface.provider;
+        this.evmSwapContract = evmSwapContract;
+        this.evmSpvVaultContract = evmSpvVaultContract;
+        this.pollIntervalSeconds = pollIntervalSeconds;
+
+        this.spvVaultContractLogFilter = {
+            address: this.evmSpvVaultContract.contractAddress
+        };
+        this.swapContractLogFilter = {
+            address: this.evmSwapContract.contractAddress
+        };
+    }
+
+    private addProcessedEvent(event: AtomiqTypedEvent) {
+        this.processedEvents[this.processedEventsIndex] = event.transactionHash+":"+event.index;
+        this.processedEventsIndex += 1;
+        if(this.processedEventsIndex >= PROCESSED_EVENTS_BACKLOG) this.processedEventsIndex = 0;
+    }
+
+    private isEventProcessed(event: AtomiqTypedEvent): boolean {
+        return this.processedEvents.includes(event.transactionHash+":"+event.index);
+    }
+
+    findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData {
+        if(call.to.toLowerCase() === this.evmSwapContract.contractAddress.toLowerCase()) {
+            const result = this.evmSwapContract.parseCalldata<typeof this.evmSwapContract.contract.initialize>(call.input);
+            if(result!=null && result.name==="initialize") {
+                //Found, check correct escrow hash
+                const [escrowData, signature, timeout, extraData] = result.args;
+                const escrow = EVMSwapData.deserializeFromStruct(escrowData, claimHandler);
+                if("0x"+escrow.getEscrowHash()===escrowHash) {
+                    const extraDataHex = hexlify(extraData);
+                    if(extraDataHex.length>2) {
+                        escrow.setExtraData(extraDataHex.substring(2));
+                    }
+                    return escrow;
+                }
+            }
+        }
+        for(let _call of call.calls) {
+            const found = this.findInitSwapData(_call, escrowHash, claimHandler);
+            if(found!=null) return found;
+        }
+        return null;
+    }
+
+    /**
+     * Returns async getter for fetching on-demand initialize event swap data
+     *
+     * @param event
+     * @param claimHandler
+     * @private
+     * @returns {() => Promise<EVMSwapData>} getter to be passed to InitializeEvent constructor
+     */
+    private getSwapDataGetter(
+        event: TypedEventLog<EscrowManager["filters"]["Initialize"]>,
+        claimHandler: IClaimHandler<any, any>
+    ): () => Promise<EVMSwapData> {
+        return async () => {
+            const trace = await this.chainInterface.Transactions.traceTransaction(event.transactionHash);
+            if(trace==null) return null;
+            return this.findInitSwapData(trace, event.args.escrowHash, claimHandler);
+        }
+    }
+
+    protected parseInitializeEvent(
+        event: TypedEventLog<EscrowManager["filters"]["Initialize"]>
+    ): InitializeEvent<EVMSwapData> {
+        const escrowHash = event.args.escrowHash.substring(2);
+        const claimHandlerHex = event.args.claimHandler;
+        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
+        if(claimHandler==null) {
+            this.logger.warn("parseInitializeEvent("+escrowHash+"): Unknown claim handler with claim: "+claimHandlerHex);
+            return null;
+        }
+        const swapType: ChainSwapType = claimHandler.getType();
+
+        this.logger.debug("InitializeEvent escrowHash: "+escrowHash);
+        return new InitializeEvent<EVMSwapData>(
+            escrowHash,
+            swapType,
+            onceAsync<EVMSwapData>(this.getSwapDataGetter(event, claimHandler))
+        );
+    }
+
+    protected parseRefundEvent(
+        event: TypedEventLog<EscrowManager["filters"]["Refund"]>
+    ): RefundEvent<EVMSwapData> {
+        const escrowHash = event.args.escrowHash.substring(2);
+        this.logger.debug("RefundEvent escrowHash: "+escrowHash);
+        return new RefundEvent<EVMSwapData>(escrowHash);
+    }
+
+    protected parseClaimEvent(
+        event: TypedEventLog<EscrowManager["filters"]["Claim"]>
+    ): ClaimEvent<EVMSwapData> {
+        const escrowHash = event.args.escrowHash.substring(2);
+        const claimHandlerHex = event.args.claimHandler;
+        const claimHandler = this.evmSwapContract.claimHandlersByAddress[claimHandlerHex.toLowerCase()];
+        if(claimHandler==null) {
+            this.logger.warn("parseClaimEvent("+escrowHash+"): Unknown claim handler with claim: "+claimHandlerHex);
+            return null;
+        }
+        const witnessResult = event.args.witnessResult.substring(2);
+        this.logger.debug("ClaimEvent witnessResult: "+witnessResult+" escrowHash: "+escrowHash);
+        return new ClaimEvent<EVMSwapData>(escrowHash, witnessResult);
+    }
+
+    protected parseSpvOpenEvent(
+        event: TypedEventLog<SpvVaultManager["filters"]["Opened"]>
+    ): SpvVaultOpenEvent {
+        const owner = event.args.owner;
+        const vaultId = event.args.vaultId;
+        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+        const vout = Number(event.args.vout);
+
+        this.logger.debug("SpvOpenEvent owner: "+owner+" vaultId: "+vaultId+" utxo: "+btcTxId+":"+vout);
+        return new SpvVaultOpenEvent(owner, vaultId, btcTxId, vout);
+    }
+
+    protected parseSpvDepositEvent(
+        event: TypedEventLog<SpvVaultManager["filters"]["Deposited"]>
+    ): SpvVaultDepositEvent {
+        const [owner, vaultId] = unpackOwnerAndVaultId(event.args.ownerAndVaultId);
+        const amounts = [event.args.amount0, event.args.amount1];
+        const depositCount = Number(event.args.depositCount);
+
+        this.logger.debug("SpvDepositEvent owner: "+owner+" vaultId: "+vaultId+" depositCount: "+depositCount+" amounts: ", amounts);
+        return new SpvVaultDepositEvent(owner, vaultId, amounts, depositCount);
+    }
+
+    protected parseSpvFrontEvent(
+        event: TypedEventLog<SpvVaultManager["filters"]["Fronted"]>
+    ): SpvVaultFrontEvent {
+        const [owner, vaultId] = unpackOwnerAndVaultId(event.args.ownerAndVaultId);
+        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+        const recipient = event.args.recipient;
+        const executionHash = event.args.executionHash;
+        const amounts = [event.args.amount0, event.args.amount1];
+        const frontingAddress = event.args.caller;
+
+        this.logger.debug("SpvFrontEvent owner: "+owner+" vaultId: "+vaultId+" btcTxId: "+btcTxId+
+            " recipient: "+recipient+" frontedBy: "+frontingAddress+" amounts: ", amounts);
+        return new SpvVaultFrontEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, frontingAddress);
+    }
+
+    protected parseSpvClaimEvent(
+        event: TypedEventLog<SpvVaultManager["filters"]["Claimed"]>
+    ): SpvVaultClaimEvent {
+        const [owner, vaultId] = unpackOwnerAndVaultId(event.args.ownerAndVaultId);
+        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+        const recipient = event.args.recipient;
+        const executionHash = event.args.executionHash;
+        const amounts = [event.args.amount0, event.args.amount1];
+        const caller = event.args.caller;
+        const frontingAddress = event.args.frontingAddress;
+        const withdrawCount = Number(event.args.withdrawCount);
+
+        this.logger.debug("SpvClaimEvent owner: "+owner+" vaultId: "+vaultId+" btcTxId: "+btcTxId+" withdrawCount: "+withdrawCount+
+            " recipient: "+recipient+" frontedBy: "+frontingAddress+" claimedBy: "+caller+" amounts: ", amounts);
+
+        return new SpvVaultClaimEvent(owner, vaultId, btcTxId, recipient, executionHash, amounts, caller, frontingAddress, withdrawCount);
+    }
+
+    protected parseSpvCloseEvent(
+        event: TypedEventLog<SpvVaultManager["filters"]["Closed"]>
+    ): SpvVaultCloseEvent {
+        const btcTxId = Buffer.from(event.args.btcTxHash.substring(2), "hex").reverse().toString("hex");
+
+        return new SpvVaultCloseEvent(event.args.owner, event.args.vaultId, btcTxId, event.args.error);
+    }
+
+    /**
+     * Processes event as received from the chain, parses it & calls event listeners
+     *
+     * @param events
+     * @param currentBlock
+     * @protected
+     */
+    protected async processEvents(
+        events : (
+            TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> |
+            TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>
+        )[],
+        currentBlock?: Block
+    ) {
+        for(let event of events) {
+            const eventIdentifier = event.transactionHash+":"+event.index;
+
+            if(this.isEventProcessed(event)) {
+                this.logger.debug("processEvents(): skipping already processed event: "+eventIdentifier);
+                continue;
+            }
+
+            let parsedEvent: ChainEvent<EVMSwapData>;
+            switch(event.eventName) {
+                case "Claim":
+                    parsedEvent = this.parseClaimEvent(event as any);
+                    break;
+                case "Refund":
+                    parsedEvent = this.parseRefundEvent(event as any);
+                    break;
+                case "Initialize":
+                    parsedEvent = this.parseInitializeEvent(event as any);
+                    break;
+                case "Opened":
+                    parsedEvent = this.parseSpvOpenEvent(event as any);
+                    break;
+                case "Deposited":
+                    parsedEvent = this.parseSpvDepositEvent(event as any);
+                    break;
+                case "Fronted":
+                    parsedEvent = this.parseSpvFrontEvent(event as any);
+                    break;
+                case "Claimed":
+                    parsedEvent = this.parseSpvClaimEvent(event as any);
+                    break;
+                case "Closed":
+                    parsedEvent = this.parseSpvCloseEvent(event as any);
+                    break;
+            }
+
+            if(this.eventsProcessing[eventIdentifier]!=null) {
+                this.logger.debug("processEvents(): awaiting event that is currently processing: "+eventIdentifier);
+                await this.eventsProcessing[eventIdentifier];
+                continue;
+            }
+
+            const promise = (async() => {
+                if(parsedEvent==null) return;
+                const timestamp = event.blockNumber===currentBlock?.number ? currentBlock.timestamp : await this.chainInterface.Blocks.getBlockTime(event.blockNumber);
+                parsedEvent.meta = {
+                    blockTime: timestamp,
+                    txId: event.transactionHash,
+                    timestamp //Maybe deprecated
+                } as any;
+                for(let listener of this.listeners) {
+                    await listener([parsedEvent]);
+                }
+                this.addProcessedEvent(event);
+            })();
+            this.eventsProcessing[eventIdentifier] = promise;
+            try {
+                await promise;
+                delete this.eventsProcessing[eventIdentifier];
+            } catch (e) {
+                delete this.eventsProcessing[eventIdentifier];
+                throw e;
+            }
+        }
+    }
+
+    protected async checkEventsEcrowManager(currentBlock: Block, lastProcessedEvent?: {blockHash: string, logIndex: number}, lastBlockNumber?: number): Promise<[{blockHash: string, logIndex: number}, number]> {
+        lastBlockNumber ??= currentBlock.number;
+        if(currentBlock.number < lastBlockNumber) {
+            this.logger.warn(`checkEventsEscrowManager(): Sanity check triggered - not processing events, currentBlock: ${currentBlock.number}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
+        // this.logger.debug(`checkEvents(EscrowManager): Requesting logs: ${lastBlockNumber}...${currentBlock.number}`);
+        let events = await this.evmSwapContract.Events.getContractBlockEvents(
+            ["Initialize", "Claim", "Refund"],
+            [],
+            lastBlockNumber,
+            currentBlock.number
+        );
+        if(lastProcessedEvent!=null) {
+            const latestProcessedEventIndex = events.findIndex(val => val.blockHash===lastProcessedEvent.blockHash && val.index===lastProcessedEvent.logIndex);
+            if(latestProcessedEventIndex!==-1) {
+                events.splice(0, latestProcessedEventIndex+1);
+                this.logger.debug("checkEvents(EscrowManager): Splicing processed events, resulting size: "+events.length);
+            }
+        }
+        if(events.length>0) {
+            await this.processEvents(events, currentBlock);
+            const lastProcessed = events[events.length-1];
+            lastProcessedEvent = {
+                blockHash: lastProcessed.blockHash,
+                logIndex: lastProcessed.index
+            }
+            if(lastProcessed.blockNumber > lastBlockNumber) lastBlockNumber = lastProcessed.blockNumber;
+        } else if(currentBlock.number - lastBlockNumber > LOGS_SLIDING_WINDOW_LENGTH) {
+            lastProcessedEvent = null;
+            lastBlockNumber = currentBlock.number - LOGS_SLIDING_WINDOW_LENGTH;
+        }
+        return [lastProcessedEvent, lastBlockNumber];
+    }
+
+    protected async checkEventsSpvVaults(currentBlock: Block, lastProcessedEvent?: {blockHash: string, logIndex: number}, lastBlockNumber?: number): Promise<[{blockHash: string, logIndex: number}, number]> {
+        lastBlockNumber ??= currentBlock.number;
+        if(currentBlock.number < lastBlockNumber) {
+            this.logger.warn(`checkEventsSpvVaults(): Sanity check triggered - not processing events, currentBlock: ${currentBlock.number}, lastBlock: ${lastBlockNumber}`);
+            return;
+        }
+        // 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
+        );
+        if(lastProcessedEvent!=null) {
+            const latestProcessedEventIndex = events.findIndex(val => val.blockHash===lastProcessedEvent.blockHash && val.index===lastProcessedEvent.logIndex);
+            if(latestProcessedEventIndex!==-1) {
+                events.splice(0, latestProcessedEventIndex+1);
+                this.logger.debug("checkEvents(SpvVaults): Splicing processed events, resulting size: "+events.length);
+            }
+        }
+        if(events.length>0) {
+            await this.processEvents(events, currentBlock);
+            const lastProcessed = events[events.length-1];
+            lastProcessedEvent = {
+                blockHash: lastProcessed.blockHash,
+                logIndex: lastProcessed.index
+            }
+            if(lastProcessed.blockNumber > lastBlockNumber) lastBlockNumber = lastProcessed.blockNumber;
+        } else if(currentBlock.number - lastBlockNumber > LOGS_SLIDING_WINDOW_LENGTH) {
+            lastProcessedEvent = null;
+            lastBlockNumber = currentBlock.number - LOGS_SLIDING_WINDOW_LENGTH;
+        }
+        return [lastProcessedEvent, lastBlockNumber];
+    }
+
+    protected async checkEvents(lastState: EVMEventListenerState[]): Promise<EVMEventListenerState[]> {
+        lastState ??= [];
+
+        const currentBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag, false);
+
+        const [lastEscrowEvent, lastEscrowHeight] = await this.checkEventsEcrowManager(currentBlock, lastState?.[0]?.lastEvent, lastState?.[0]?.lastBlockNumber);
+        const [lastSpvVaultEvent, lastSpvVaultHeight] = await this.checkEventsSpvVaults(currentBlock, lastState?.[1]?.lastEvent, lastState?.[1]?.lastBlockNumber);
+
+        lastState = [
+            {lastBlockNumber: lastEscrowHeight, lastEvent: lastEscrowEvent},
+            {lastBlockNumber: lastSpvVaultHeight, lastEvent: lastSpvVaultEvent}
+        ];
+
+        return lastState;
+    }
+
+    /**
+     * Sets up event handlers listening for swap events over websocket
+     *
+     * @protected
+     */
+    protected async setupPoll(
+        lastState?: EVMEventListenerState[],
+        saveLatestProcessedBlockNumber?: (newState: EVMEventListenerState[]) => Promise<void>
+    ) {
+        this.stopped = false;
+        let func;
+        func = async () => {
+            await this.checkEvents(lastState).then(newState => {
+                lastState = newState;
+                if(saveLatestProcessedBlockNumber!=null) return saveLatestProcessedBlockNumber(newState);
+            }).catch(e => {
+                this.logger.error("setupPoll(): Failed to fetch evm log: ", e);
+            });
+            if(this.stopped) return;
+            this.timeout = setTimeout(func, this.pollIntervalSeconds*1000) as any;
+        };
+        await func();
+    }
+
+    //Websocket
+
+    protected handleWsEvents(
+        events : AtomiqTypedEvent[]
+    ): Promise<void> {
+        if(this.chainInterface.config.safeBlockTag==="latest" || this.chainInterface.config.safeBlockTag==="pending") {
+            return this.processEvents(events);
+        }
+        this.unconfirmedEventQueue.push(...events);
+    }
+
+    protected spvVaultContractListener: (log: Log) => void;
+    protected swapContractListener: (log: Log) => void;
+    protected blockListener: (blockNumber: number) => Promise<void>;
+
+    protected wsStarted: boolean = false;
+
+    protected async setupWebsocket() {
+        this.wsStarted = true;
+
+        await this.provider.on(this.spvVaultContractLogFilter, this.spvVaultContractListener = (log) => {
+            let events = this.evmSpvVaultContract.Events.toTypedEvents([log]);
+            events = events.filter(val => !val.removed);
+            this.handleWsEvents(events);
+        });
+
+        await this.provider.on(this.swapContractLogFilter, this.swapContractListener = (log) => {
+            let events = this.evmSwapContract.Events.toTypedEvents([log]);
+            events = events.filter(val => !val.removed && (val.eventName==="Initialize" || val.eventName==="Refund" || val.eventName==="Claim"));
+            this.handleWsEvents(events);
+        });
+
+        const safeBlockTag = this.chainInterface.config.safeBlockTag;
+        let processing = false;
+        if(safeBlockTag!=="latest" && safeBlockTag!=="pending") await this.provider.on("block", this.blockListener = async (blockNumber: number) => {
+            if(processing) return;
+            if(this.unconfirmedEventQueue.length===0) return;
+            processing = true;
+            try {
+                const latestSafeBlock = await this.provider.getBlock(this.chainInterface.config.safeBlockTag);
+
+                const events = [];
+                this.unconfirmedEventQueue = this.unconfirmedEventQueue.filter(event => {
+                    if(event.blockNumber <= latestSafeBlock.number) {
+                        events.push(event);
+                        return false;
+                    }
+                    return true;
+                });
+
+                const blocks: {[blockNumber: number]: Block} = {};
+                for(let event of events) {
+                    const block = blocks[event.blockNumber] ?? (blocks[event.blockNumber] = await this.provider.getBlock(event.blockNumber));
+                    if(block.hash===event.blockHash) {
+                        //Valid event
+                        await this.processEvents([event], block);
+                    } else {
+                        //Block hash doesn't match
+                    }
+                }
+            } catch (e) {
+                this.logger.error(`on('block'): Error when processing new block ${blockNumber}:`, e);
+            }
+            processing = false;
+        });
+    }
+
+    async init(): Promise<void> {
+        if((this.provider as any).websocket!=null) {
+            await this.setupWebsocket();
+        } else {
+            await this.setupPoll();
+        }
+        this.stopped = false;
+        return Promise.resolve();
+    }
+
+    async stop(): Promise<void> {
+        this.stopped = true;
+        if(this.timeout!=null) clearTimeout(this.timeout);
+        if(this.wsStarted) {
+            await this.provider.off(this.spvVaultContractLogFilter, this.spvVaultContractListener);
+            await this.provider.off(this.swapContractLogFilter, this.swapContractListener);
+            await this.provider.off("block", this.blockListener);
+            this.wsStarted = false;
+        }
+    }
+
+    registerListener(cbk: EventListener<EVMSwapData>): void {
+        this.listeners.push(cbk);
+    }
+
+    unregisterListener(cbk: EventListener<EVMSwapData>): boolean {
+        const index = this.listeners.indexOf(cbk);
+        if(index>=0) {
+            this.listeners.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+}

package/src/evm/providers/JsonRpcProviderWithRetries.ts

@@ -0,0 +1,34 @@
+import {JsonRpcProvider, JsonRpcApiProviderOptions, makeError, JsonRpcPayload, JsonRpcResult} from "ethers";
+import {Networkish, FetchRequest} from "ethers";
+import {
+    allowedEthersErrorCodes,
+    allowedEthersErrorMessages,
+    allowedEthersErrorNumbers,
+    tryWithRetries
+} from "../../utils/Utils";
+
+export class JsonRpcProviderWithRetries extends JsonRpcProvider {
+
+    readonly retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    };
+
+    constructor(url?: string | FetchRequest, network?: Networkish, options?: JsonRpcApiProviderOptions & {
+        maxRetries?: number, delay?: number, exponential?: boolean, timeout?: number
+    }) {
+        if(typeof(url)==="string") url = new FetchRequest(url);
+        url.timeout = options?.timeout ?? 10*1000;
+        super(url, network, options);
+        this.retryPolicy = options;
+    }
+
+    send(method: string, params: Array<any> | Record<string, any>): Promise<any> {
+        return tryWithRetries(() => super.send(method, params), this.retryPolicy, e => {
+            if(e.code!=null && typeof(e.code)==="string" && allowedEthersErrorCodes.has(e.code)) return true;
+            if(e.error?.code!=null && typeof(e.error.code)==="number" && allowedEthersErrorNumbers.has(e.error.code)) return true;
+            if(e.error?.message!=null && typeof(e.error.message)==="string" && allowedEthersErrorMessages.has(e.error.message)) return true;
+            return false;
+        });
+    }
+
+}

package/src/evm/providers/ReconnectingWebSocketProvider.ts

@@ -0,0 +1,107 @@
+import {JsonRpcApiProviderOptions} from "ethers";
+import type {Networkish, WebSocketLike} from "ethers";
+import {SocketProvider} from "./SocketProvider";
+import {getLogger} from "../../utils/Utils";
+
+const logger = getLogger("ReconnectingWebSocketProvider: ");
+
+export class ReconnectingWebSocketProvider extends SocketProvider {
+
+    requestTimeoutSeconds: number = 10;
+    reconnectSeconds: number = 5;
+    pingIntervalSeconds: number = 30;
+    connectionTimeout: number = 10;
+
+    pingInterval: any;
+    reconnectTimer: any;
+    connectTimer: any;
+
+    wsCtor: () => WebSocketLike;
+    websocket: null | WebSocketLike & {onclose?: (...args: any[]) => void, ping?: () => void};
+
+    constructor(url: string | (() => WebSocketLike), network?: Networkish, options?: JsonRpcApiProviderOptions) {
+        super(network, options);
+        this.wsCtor = typeof(url)==="string" ? () => new WebSocket(url) : url;
+        this.connect();
+    }
+
+    private connect() {
+        this.websocket = this.wsCtor();
+
+        this.websocket.onopen = () => {
+            this._connected();
+            this._start();
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+
+            this.pingInterval = setInterval(() => {
+                this._send({method: "eth_chainId", params: [], id: 1_000_000_000, jsonrpc: "2.0"}).catch(e => {
+                    //Error
+                    if(e.code==="NETWORK_ERROR") {
+                        logger.error("connect(): pingInterval: Websocket ping error: ", e);
+                        if(this.websocket!=null) {
+                            this.websocket.close();
+                            this.disconnectedAndScheduleReconnect();
+                        }
+                    }
+                });
+            }, this.pingIntervalSeconds * 1000);
+
+            logger.info("connect(): Websocket connected!");
+        };
+
+        this.websocket.onerror = (err) => {
+            logger.error(`connect(): onerror: Websocket connection error: `, err);
+            this.disconnectedAndScheduleReconnect();
+        };
+
+        this.websocket.onmessage = (message: { data: string }) => {
+            this._processMessage(message.data);
+        };
+
+        this.websocket.onclose = (event) => {
+            logger.error(`connect(): onclose: Websocket connection closed: `, event);
+            this.disconnectedAndScheduleReconnect();
+        };
+
+        this.connectTimer = setTimeout(() => {
+            logger.warn("connect(): Websocket connection taking too long, (above "+this.connectionTimeout+" seconds!), closing and re-attempting connection");
+            this.websocket.close();
+            this.disconnectedAndScheduleReconnect();
+        }, this.connectionTimeout * 1000);
+    }
+
+    private disconnectedAndScheduleReconnect() {
+        if(this.destroyed) return;
+        if(this.websocket==null) return;
+        this.websocket.onclose = null;
+        //Register dummy handler, otherwise we get unhandled `error` event which crashes the whole thing
+        this.websocket.onerror = (err) => logger.error("disconnectedAndScheduleReconnect(): Post-close onerror: ", err);
+        this.websocket.onmessage = null;
+        this.websocket.onopen = null;
+        this.websocket = null;
+        if(this.pingInterval!=null) clearInterval(this.pingInterval);
+        if(this.connectTimer!=null) clearInterval(this.connectTimer);
+
+        this._disconnected();
+
+        logger.info(`disconnectedAndScheduleReconnect(): Retrying in ${this.reconnectSeconds} seconds...`);
+        this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+    }
+
+    async _write(message: string): Promise<void> {
+        this.websocket.send(message);
+    }
+
+    async destroy(): Promise<void> {
+        if (this.websocket != null) {
+            this.websocket.close();
+            this.websocket = null;
+        }
+        if(this.reconnectTimer!=null) clearTimeout(this.reconnectTimer);
+        if(this.pingInterval!=null) clearInterval(this.pingInterval);
+        if(this.connectTimer!=null) clearInterval(this.connectTimer);
+        super.destroy();
+    }
+
+}