@atomiqlabs/chain-evm 1.0.0-dev.50 → 1.0.0-dev.52

package/src/evm/SocketProvider.ts

@@ -0,0 +1,353 @@
+/**
+ *  Generic long-lived socket provider.
+ *
+ *  Sub-classing notes
+ *  - a sub-class MUST call the `_start()` method once connected
+ *  - a sub-class MUST override the `_write(string)` method
+ *  - a sub-class MUST call `_processMessage(string)` for each message
+ *
+ *  @_subsection: api/providers/abstract-provider:Socket Providers  [about-socketProvider]
+ */
+import {
+    assert,
+    assertArgument, EventFilter,
+    JsonRpcApiProvider,
+    JsonRpcApiProviderOptions, JsonRpcError,
+    JsonRpcPayload, JsonRpcResult, makeError,
+    Networkish,
+    Subscriber, Subscription, UnmanagedSubscriber
+} from "ethers";
+
+
+type JsonRpcSubscription = {
+    method: string,
+    params: {
+        result: any,
+        subscription: string
+    }
+};
+
+/**
+ *  A **SocketSubscriber** uses a socket transport to handle events and
+ *  should use [[_emit]] to manage the events.
+ */
+export class SocketSubscriber implements Subscriber {
+    #provider: SocketProvider;
+
+    #filter: string;
+
+    /**
+     *  The filter.
+     */
+    get filter(): Array<any> { return JSON.parse(this.#filter); }
+
+    #filterId: null | Promise<string |number>;
+    #paused: null | boolean;
+
+    #emitPromise: null | Promise<void>;
+
+    /**
+     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
+     *  to %%filter%%.
+     */
+    constructor(provider: SocketProvider, filter: Array<any>) {
+        this.#provider = provider;
+        this.#filter = JSON.stringify(filter);
+        this.#filterId = null;
+        this.#paused = null;
+        this.#emitPromise = null;
+    }
+
+    start(): void {
+        this.#filterId = this.#provider.send("eth_subscribe", this.filter).then((filterId) => {;
+            this.#provider._register(filterId, this);
+            return filterId;
+        });
+    }
+
+    stop(): void {
+        (<Promise<number>>(this.#filterId)).then((filterId) => {
+            if (this.#provider.destroyed) { return; }
+            this.#provider.send("eth_unsubscribe", [ filterId ]);
+        });
+        this.#filterId = null;
+    }
+
+    // @TODO: pause should trap the current blockNumber, unsub, and on resume use getLogs
+    //        and resume
+    pause(dropWhilePaused?: boolean): void {
+        assert(dropWhilePaused, "preserve logs while paused not supported by SocketSubscriber yet",
+            "UNSUPPORTED_OPERATION", { operation: "pause(false)" });
+        this.#paused = !!dropWhilePaused;
+    }
+
+    resume(): void {
+        this.#paused = null;
+    }
+
+    /**
+     *  @_ignore:
+     */
+    _handleMessage(message: any): void {
+        if (this.#filterId == null) { return; }
+        if (this.#paused === null) {
+            let emitPromise: null | Promise<void> = this.#emitPromise;
+            if (emitPromise == null) {
+                emitPromise = this._emit(this.#provider, message);
+            } else {
+                emitPromise = emitPromise.then(async () => {
+                    await this._emit(this.#provider, message);
+                });
+            }
+            this.#emitPromise = emitPromise.then(() => {
+                if (this.#emitPromise === emitPromise) {
+                    this.#emitPromise = null;
+                }
+            });
+        }
+    }
+
+    /**
+     *  Sub-classes **must** override this to emit the events on the
+     *  provider.
+     */
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        throw new Error("sub-classes must implemente this; _emit");
+    }
+}
+
+/**
+ *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
+ *  ``"block"`` events.
+ */
+export class SocketBlockSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider) {
+        super(provider, [ "newHeads" ]);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit("block", parseInt(message.number));
+    }
+}
+
+/**
+ *  A **SocketPendingSubscriber** listens for pending transacitons and emits
+ *  ``"pending"`` events.
+ */
+export class SocketPendingSubscriber extends SocketSubscriber {
+
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider) {
+        super(provider, [ "newPendingTransactions" ]);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit("pending", message);
+    }
+}
+
+/**
+ *  A **SocketEventSubscriber** listens for event logs.
+ */
+export class SocketEventSubscriber extends SocketSubscriber {
+    #logFilter: string;
+
+    /**
+     *  The filter.
+     */
+    get logFilter(): EventFilter { return JSON.parse(this.#logFilter); }
+
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider, filter: EventFilter) {
+        super(provider, [ "logs", filter ]);
+        this.#logFilter = JSON.stringify(filter);
+    }
+
+    async _emit(provider: SocketProvider, message: any): Promise<void> {
+        provider.emit(this.logFilter, provider._wrapLog(message, provider._network));
+    }
+}
+
+/**
+ *  A **SocketProvider** is backed by a long-lived connection over a
+ *  socket, which can subscribe and receive real-time messages over
+ *  its communication channel.
+ */
+export class SocketProvider extends JsonRpcApiProvider {
+    #callbacks: Map<number, { payload: JsonRpcPayload, resolve: (r: any) => void, reject: (e: Error) => void }>;
+
+    // Maps each filterId to its subscriber
+    #subs: Map<number | string, SocketSubscriber>;
+
+    // If any events come in before a subscriber has finished
+    // registering, queue them
+    #pending: Map<number | string, Array<any>>;
+
+    #connected: boolean;
+
+    /**
+     *  Creates a new **SocketProvider** connected to %%network%%.
+     *
+     *  If unspecified, the network will be discovered.
+     */
+    constructor(network?: Networkish, _options?: JsonRpcApiProviderOptions) {
+        // Copy the options
+        const options = Object.assign({ }, (_options != null) ? _options: { });
+
+        // Support for batches is generally not supported for
+        // connection-base providers; if this changes in the future
+        // the _send should be updated to reflect this
+        assertArgument(options.batchMaxCount == null || options.batchMaxCount === 1,
+            "sockets-based providers do not support batches", "options.batchMaxCount", _options);
+        options.batchMaxCount = 1;
+
+        // Socket-based Providers (generally) cannot change their network,
+        // since they have a long-lived connection; but let people override
+        // this if they have just cause.
+        if (options.staticNetwork == null) { options.staticNetwork = true; }
+
+        super(network, options);
+        this.#callbacks = new Map();
+        this.#subs = new Map();
+        this.#pending = new Map();
+    }
+
+    // This value is only valid after _start has been called
+    /*
+    get _network(): Network {
+        if (this.#network == null) {
+            throw new Error("this shouldn't happen");
+        }
+        return this.#network.clone();
+    }
+    */
+
+    _getSubscriber(sub: Subscription): Subscriber {
+        switch (sub.type) {
+            case "close":
+                return new UnmanagedSubscriber("close");
+            case "block":
+                return new SocketBlockSubscriber(this);
+            case "pending":
+                return new SocketPendingSubscriber(this);
+            case "event":
+                return new SocketEventSubscriber(this, sub.filter);
+            case "orphan":
+                // Handled auto-matically within AbstractProvider
+                // when the log.removed = true
+                if (sub.filter.orphan === "drop-log") {
+                    return new UnmanagedSubscriber("drop-log");
+                }
+        }
+        return super._getSubscriber(sub);
+    }
+
+    /**
+     *  Register a new subscriber. This is used internalled by Subscribers
+     *  and generally is unecessary unless extending capabilities.
+     */
+    _register(filterId: number | string, subscriber: SocketSubscriber): void {
+        this.#subs.set(filterId, subscriber);
+        const pending = this.#pending.get(filterId);
+        if (pending) {
+            for (const message of pending) {
+                subscriber._handleMessage(message);
+            }
+            this.#pending.delete(filterId);
+        }
+    }
+
+    async _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>> {
+        // WebSocket provider doesn't accept batches
+        assertArgument(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload);
+
+        if(!this.#connected) return Promise.reject(makeError("WebSocket not connected!", "NETWORK_ERROR"));
+
+        // Prepare a promise to respond to
+        const promise = new Promise((resolve, reject) => {
+            this.#callbacks.set(payload.id, { payload, resolve, reject });
+        });
+
+        // Wait until the socket is connected before writing to it
+        await this._waitUntilReady();
+
+        // Write the request to the socket
+        await this._write(JSON.stringify(payload));
+
+        return <Array<JsonRpcResult | JsonRpcError>>[ await promise ];
+    }
+
+    _connected() {
+        this.#connected = true;
+        this.resume();
+        this._forEachSubscriber(subscriber => subscriber.start());
+    }
+
+    _disconnected() {
+        this.#connected = false;
+        this.pause(true);
+
+        this.#callbacks.forEach(val => {
+            val.reject(makeError("WebSocket disconnected!", "NETWORK_ERROR"))
+        });
+        this.#callbacks.clear();
+    }
+
+    /**
+     *  Sub-classes **must** call this with messages received over their
+     *  transport to be processed and dispatched.
+     */
+    async _processMessage(message: string): Promise<void> {
+        const result = <JsonRpcResult | JsonRpcError | JsonRpcSubscription>(JSON.parse(message));
+
+        if (result && typeof(result) === "object" && "id" in result) {
+            const callback = this.#callbacks.get(result.id);
+            if (callback == null) {
+                this.emit("error", makeError("received result for unknown id", "UNKNOWN_ERROR", {
+                    reasonCode: "UNKNOWN_ID",
+                    result
+                }));
+                return;
+            }
+            this.#callbacks.delete(result.id);
+
+            callback.resolve(result);
+
+        } else if (result && (result as any).method === "eth_subscription") {
+            const filterId = (result as any).params.subscription;
+            const subscriber = this.#subs.get(filterId);
+            if (subscriber) {
+                subscriber._handleMessage((result as any).params.result);
+            } else {
+                let pending = this.#pending.get(filterId);
+                if (pending == null) {
+                    pending = [ ];
+                    this.#pending.set(filterId, pending);
+                }
+                pending.push((result as any).params.result);
+            }
+
+        } else {
+            this.emit("error", makeError("received unexpected message", "UNKNOWN_ERROR", {
+                reasonCode: "UNEXPECTED_MESSAGE",
+                result
+            }));
+            return;
+        }
+    }
+
+    /**
+     *  Sub-classes **must** override this to send %%message%% over their
+     *  transport.
+     */
+    async _write(message: string): Promise<void> {
+        throw new Error("sub-classes must override this");
+    }
+}

package/src/evm/WebSocketProviderWithRetries.ts

@@ -0,0 +1,27 @@
+import {JsonRpcApiProviderOptions, WebSocketProvider} from "ethers";
+import type {Networkish, WebSocketCreator, WebSocketLike} from "ethers";
+import {tryWithRetries} from "../utils/Utils";
+
+
+export class WebSocketProviderWithRetries extends WebSocketProvider {
+
+    readonly retryPolicy?: {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    };
+
+    constructor(url: string | WebSocketLike | WebSocketCreator, network?: Networkish, options?: JsonRpcApiProviderOptions & {
+        maxRetries?: number, delay?: number, exponential?: boolean
+    }) {
+        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 => {
+            return false;
+            // if(e?.error?.code!=null) return false; //Error returned by the RPC
+            // return true;
+        });
+    }
+
+}

package/src/evm/events/EVMChainEvents.ts

@@ -72,6 +72,7 @@ export class EVMChainEvents extends EVMChainEventsBrowser {
 
     async init(): Promise<void> {
         const lastState = await this.getLastEventData();
+        if((this.provider as any).websocket!=null) await this.setupWebsocket();
         await this.setupPoll(
             lastState,
             (newState: EVMEventListenerState[]) => this.saveLastEventData(newState)

package/src/evm/events/EVMChainEventsBrowser.ts

@@ -9,7 +9,7 @@ import {
 } from "@atomiqlabs/base";
 import {IClaimHandler} from "../swaps/handlers/claim/ClaimHandlers";
 import {EVMSwapData} from "../swaps/EVMSwapData";
-import {Block, hexlify, JsonRpcApiProvider} from "ethers";
+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";
@@ -21,8 +21,15 @@ 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
@@ -30,6 +37,12 @@ export type EVMEventListenerState = {lastBlockNumber: number, lastEvent?: {block
  */
 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;
@@ -42,6 +55,12 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
 
     private timeout: number;
 
+    //Websocket
+    protected readonly spvVaultContractLogFilter: EventFilter;
+    protected readonly swapContractLogFilter: EventFilter;
+
+    protected unconfirmedEventQueue: AtomiqTypedEvent[] = [];
+
     constructor(
         chainInterface: EVMChainInterface,
         evmSwapContract: EVMSwapContract,
@@ -53,6 +72,23 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         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.transactionIndex;
+        this.processedEventsIndex += 1;
+        if(this.processedEventsIndex >= PROCESSED_EVENTS_BACKLOG) this.processedEventsIndex = 0;
+    }
+
+    private isEventProcessed(event: AtomiqTypedEvent): boolean {
+        return this.processedEvents.includes(event.transactionHash+":"+event.transactionIndex);
     }
 
     findInitSwapData(call: EVMTxTrace, escrowHash: string, claimHandler: IClaimHandler<any, any>): EVMSwapData {
@@ -216,11 +252,16 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
             TypedEventLog<EscrowManager["filters"]["Initialize" | "Refund" | "Claim"]> |
             TypedEventLog<SpvVaultManager["filters"]["Opened" | "Deposited" | "Fronted" | "Claimed" | "Closed"]>
         )[],
-        currentBlock: Block
+        currentBlock?: Block
     ) {
-        const parsedEvents: ChainEvent<EVMSwapData>[] = [];
-
         for(let event of events) {
+            const eventIdentifier = event.transactionHash+":"+event.transactionIndex;
+
+            if(this.isEventProcessed(event)) {
+                this.logger.debug("processEvents(): skipping already processed event: "+eventIdentifier);
+                continue;
+            }
+
             let parsedEvent: ChainEvent<EVMSwapData>;
             switch(event.eventName) {
                 case "Claim":
@@ -248,17 +289,33 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
                     parsedEvent = this.parseSpvCloseEvent(event as any);
                     break;
             }
-            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;
-            parsedEvents.push(parsedEvent);
-        }
 
-        for(let listener of this.listeners) {
-            await listener(parsedEvents);
+            if(this.eventsProcessing[eventIdentifier]!=null) {
+                this.logger.debug("processEvents(): awaiting event that is currently processing: "+eventIdentifier);
+                await this.eventsProcessing[eventIdentifier];
+                continue;
+            }
+
+            const promise = (async() => {
+                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;
+            }
         }
     }
 
@@ -364,8 +421,78 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
         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;
+            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> {
-        this.setupPoll();
+        if((this.provider as any).websocket!=null) {
+            await this.setupWebsocket();
+        } else {
+            await this.setupPoll();
+        }
         this.stopped = false;
         return Promise.resolve();
     }
@@ -373,6 +500,12 @@ export class EVMChainEventsBrowser implements ChainEvents<EVMSwapData> {
     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 {

package/src/index.ts

@@ -17,7 +17,6 @@ export * from "./evm/contract/EVMContractBase";
 export * from "./evm/contract/EVMContractModule";
 
 export * from "./evm/events/EVMChainEventsBrowser";
-export * from "./evm/events/EVMChainEventsBrowserWS";
 
 export * from "./evm/spv_swap/EVMSpvVaultContract";
 export * from "./evm/spv_swap/EVMSpvWithdrawalData";
@@ -49,3 +48,5 @@ export * from "./chains/botanix/BotanixInitializer";
 export * from "./chains/botanix/BotanixChainType";
 
 export * from "./evm/JsonRpcProviderWithRetries";
+export * from "./evm/WebSocketProviderWithRetries";
+export * from "./evm/ReconnectingWebSocketProvider";