@atomiqlabs/chain-evm 1.0.0-dev.75 → 1.0.0-dev.77

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

@@ -1,15 +1,15 @@
-import { JsonRpcProvider, JsonRpcApiProviderOptions } from "ethers";
-import type { Networkish, FetchRequest } from "ethers";
-export declare 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;
-    });
-    send(method: string, params: Array<any> | Record<string, any>): Promise<any>;
-}
+import { JsonRpcProvider, JsonRpcApiProviderOptions } from "ethers";
+import type { Networkish, FetchRequest } from "ethers";
+export declare 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;
+    });
+    send(method: string, params: Array<any> | Record<string, any>): Promise<any>;
+}

package/dist/evm/providers/JsonRpcProviderWithRetries.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonRpcProviderWithRetries = void 0;
-const ethers_1 = require("ethers");
-const Utils_1 = require("../../utils/Utils");
-class JsonRpcProviderWithRetries extends ethers_1.JsonRpcProvider {
-    constructor(url, network, options) {
-        super(url, network, options);
-        this.retryPolicy = options;
-    }
-    send(method, params) {
-        return (0, Utils_1.tryWithRetries)(() => super.send(method, params), this.retryPolicy, e => {
-            if (e.code != null && typeof (e.code) === "string")
-                return Utils_1.allowedEthersErrorCodes.has(e.code);
-            return false;
-        });
-    }
-}
-exports.JsonRpcProviderWithRetries = JsonRpcProviderWithRetries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcProviderWithRetries = void 0;
+const ethers_1 = require("ethers");
+const Utils_1 = require("../../utils/Utils");
+class JsonRpcProviderWithRetries extends ethers_1.JsonRpcProvider {
+    constructor(url, network, options) {
+        super(url, network, options);
+        this.retryPolicy = options;
+    }
+    send(method, params) {
+        return (0, Utils_1.tryWithRetries)(() => super.send(method, params), this.retryPolicy, e => {
+            if (e.code != null && typeof (e.code) === "string")
+                return Utils_1.allowedEthersErrorCodes.has(e.code);
+            return false;
+        });
+    }
+}
+exports.JsonRpcProviderWithRetries = JsonRpcProviderWithRetries;

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

@@ -1,22 +1,22 @@
-import { JsonRpcApiProviderOptions } from "ethers";
-import type { Networkish, WebSocketLike } from "ethers";
-import { SocketProvider } from "./SocketProvider";
-export declare class ReconnectingWebSocketProvider extends SocketProvider {
-    requestTimeoutSeconds: number;
-    reconnectSeconds: number;
-    pingIntervalSeconds: number;
-    connectionTimeout: number;
-    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);
-    private connect;
-    private disconnectedAndScheduleReconnect;
-    _write(message: string): Promise<void>;
-    destroy(): Promise<void>;
-}
+import { JsonRpcApiProviderOptions } from "ethers";
+import type { Networkish, WebSocketLike } from "ethers";
+import { SocketProvider } from "./SocketProvider";
+export declare class ReconnectingWebSocketProvider extends SocketProvider {
+    requestTimeoutSeconds: number;
+    reconnectSeconds: number;
+    pingIntervalSeconds: number;
+    connectionTimeout: number;
+    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);
+    private connect;
+    private disconnectedAndScheduleReconnect;
+    _write(message: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/evm/providers/ReconnectingWebSocketProvider.js

@@ -1,87 +1,87 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReconnectingWebSocketProvider = void 0;
-const SocketProvider_1 = require("./SocketProvider");
-class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
-    constructor(url, network, options) {
-        super(network, options);
-        this.requestTimeoutSeconds = 10;
-        this.reconnectSeconds = 5;
-        this.pingIntervalSeconds = 30;
-        this.connectionTimeout = 30;
-        this.wsCtor = typeof (url) === "string" ? () => new WebSocket(url) : url;
-        this.connect();
-    }
-    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_blockNumber", params: [], id: 1000000000, jsonrpc: "2.0" }).catch(e => {
-                    //Error
-                    if (e.code === "NETWORK_ERROR") {
-                        console.error("Websocket ping error: ", e);
-                        if (this.websocket != null) {
-                            this.websocket.close();
-                            this.disconnectedAndScheduleReconnect();
-                        }
-                    }
-                });
-            }, this.pingIntervalSeconds * 1000);
-        };
-        this.websocket.onerror = (err) => {
-            console.error(`Websocket connection error: `, err);
-            this.disconnectedAndScheduleReconnect();
-        };
-        this.websocket.onmessage = (message) => {
-            this._processMessage(message.data);
-        };
-        this.websocket.onclose = (event) => {
-            console.error(`Websocket connection closed: `, event);
-            this.disconnectedAndScheduleReconnect();
-        };
-        this.connectTimer = setTimeout(() => {
-            console.error("Websocket connection taking too long, (above " + this.connectionTimeout + " seconds!), closing and re-attempting connection");
-            this.websocket.close();
-            this.disconnectedAndScheduleReconnect();
-        }, this.connectionTimeout * 1000);
-    }
-    disconnectedAndScheduleReconnect() {
-        if (this.destroyed)
-            return;
-        if (this.websocket == null)
-            return;
-        this.websocket.onclose = null;
-        this.websocket.onerror = null;
-        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();
-        console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
-        this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
-    }
-    async _write(message) {
-        this.websocket.send(message);
-    }
-    async destroy() {
-        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();
-    }
-}
-exports.ReconnectingWebSocketProvider = ReconnectingWebSocketProvider;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectingWebSocketProvider = void 0;
+const SocketProvider_1 = require("./SocketProvider");
+class ReconnectingWebSocketProvider extends SocketProvider_1.SocketProvider {
+    constructor(url, network, options) {
+        super(network, options);
+        this.requestTimeoutSeconds = 10;
+        this.reconnectSeconds = 5;
+        this.pingIntervalSeconds = 30;
+        this.connectionTimeout = 30;
+        this.wsCtor = typeof (url) === "string" ? () => new WebSocket(url) : url;
+        this.connect();
+    }
+    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_blockNumber", params: [], id: 1000000000, jsonrpc: "2.0" }).catch(e => {
+                    //Error
+                    if (e.code === "NETWORK_ERROR") {
+                        console.error("Websocket ping error: ", e);
+                        if (this.websocket != null) {
+                            this.websocket.close();
+                            this.disconnectedAndScheduleReconnect();
+                        }
+                    }
+                });
+            }, this.pingIntervalSeconds * 1000);
+        };
+        this.websocket.onerror = (err) => {
+            console.error(`Websocket connection error: `, err);
+            this.disconnectedAndScheduleReconnect();
+        };
+        this.websocket.onmessage = (message) => {
+            this._processMessage(message.data);
+        };
+        this.websocket.onclose = (event) => {
+            console.error(`Websocket connection closed: `, event);
+            this.disconnectedAndScheduleReconnect();
+        };
+        this.connectTimer = setTimeout(() => {
+            console.error("Websocket connection taking too long, (above " + this.connectionTimeout + " seconds!), closing and re-attempting connection");
+            this.websocket.close();
+            this.disconnectedAndScheduleReconnect();
+        }, this.connectionTimeout * 1000);
+    }
+    disconnectedAndScheduleReconnect() {
+        if (this.destroyed)
+            return;
+        if (this.websocket == null)
+            return;
+        this.websocket.onclose = null;
+        this.websocket.onerror = null;
+        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();
+        console.error(`Retrying in ${this.reconnectSeconds} seconds...`);
+        this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectSeconds * 1000);
+    }
+    async _write(message) {
+        this.websocket.send(message);
+    }
+    async destroy() {
+        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();
+    }
+}
+exports.ReconnectingWebSocketProvider = ReconnectingWebSocketProvider;

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

@@ -1,111 +1,111 @@
-/**
- *  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 { EventFilter, JsonRpcApiProvider, JsonRpcApiProviderOptions, JsonRpcError, JsonRpcPayload, JsonRpcResult, Networkish, Subscriber, Subscription } from "ethers";
-/**
- *  A **SocketSubscriber** uses a socket transport to handle events and
- *  should use [[_emit]] to manage the events.
- */
-export declare class SocketSubscriber implements Subscriber {
-    #private;
-    /**
-     *  The filter.
-     */
-    get filter(): Array<any>;
-    /**
-     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
-     *  to %%filter%%.
-     */
-    constructor(provider: SocketProvider, filter: Array<any>);
-    start(): void;
-    stop(): void;
-    pause(dropWhilePaused?: boolean): void;
-    resume(): void;
-    /**
-     *  @_ignore:
-     */
-    _handleMessage(message: any): void;
-    /**
-     *  Sub-classes **must** override this to emit the events on the
-     *  provider.
-     */
-    _emit(provider: SocketProvider, message: any): Promise<void>;
-}
-/**
- *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
- *  ``"block"`` events.
- */
-export declare class SocketBlockSubscriber extends SocketSubscriber {
-    /**
-     *  @_ignore:
-     */
-    constructor(provider: SocketProvider);
-    _emit(provider: SocketProvider, message: any): Promise<void>;
-}
-/**
- *  A **SocketPendingSubscriber** listens for pending transacitons and emits
- *  ``"pending"`` events.
- */
-export declare class SocketPendingSubscriber extends SocketSubscriber {
-    /**
-     *  @_ignore:
-     */
-    constructor(provider: SocketProvider);
-    _emit(provider: SocketProvider, message: any): Promise<void>;
-}
-/**
- *  A **SocketEventSubscriber** listens for event logs.
- */
-export declare class SocketEventSubscriber extends SocketSubscriber {
-    #private;
-    /**
-     *  The filter.
-     */
-    get logFilter(): EventFilter;
-    /**
-     *  @_ignore:
-     */
-    constructor(provider: SocketProvider, filter: EventFilter);
-    _emit(provider: SocketProvider, message: any): Promise<void>;
-}
-/**
- *  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 declare class SocketProvider extends JsonRpcApiProvider {
-    #private;
-    requestTimeoutSeconds: number;
-    /**
-     *  Creates a new **SocketProvider** connected to %%network%%.
-     *
-     *  If unspecified, the network will be discovered.
-     */
-    constructor(network?: Networkish, _options?: JsonRpcApiProviderOptions);
-    _getSubscriber(sub: Subscription): Subscriber;
-    /**
-     *  Register a new subscriber. This is used internalled by Subscribers
-     *  and generally is unecessary unless extending capabilities.
-     */
-    _register(filterId: number | string, subscriber: SocketSubscriber): void;
-    _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>>;
-    _connected(): void;
-    _disconnected(): void;
-    /**
-     *  Sub-classes **must** call this with messages received over their
-     *  transport to be processed and dispatched.
-     */
-    _processMessage(message: string): Promise<void>;
-    /**
-     *  Sub-classes **must** override this to send %%message%% over their
-     *  transport.
-     */
-    _write(message: string): Promise<void>;
-}
+/**
+ *  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 { EventFilter, JsonRpcApiProvider, JsonRpcApiProviderOptions, JsonRpcError, JsonRpcPayload, JsonRpcResult, Networkish, Subscriber, Subscription } from "ethers";
+/**
+ *  A **SocketSubscriber** uses a socket transport to handle events and
+ *  should use [[_emit]] to manage the events.
+ */
+export declare class SocketSubscriber implements Subscriber {
+    #private;
+    /**
+     *  The filter.
+     */
+    get filter(): Array<any>;
+    /**
+     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
+     *  to %%filter%%.
+     */
+    constructor(provider: SocketProvider, filter: Array<any>);
+    start(): void;
+    stop(): void;
+    pause(dropWhilePaused?: boolean): void;
+    resume(): void;
+    /**
+     *  @_ignore:
+     */
+    _handleMessage(message: any): void;
+    /**
+     *  Sub-classes **must** override this to emit the events on the
+     *  provider.
+     */
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
+ *  ``"block"`` events.
+ */
+export declare class SocketBlockSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketPendingSubscriber** listens for pending transacitons and emits
+ *  ``"pending"`` events.
+ */
+export declare class SocketPendingSubscriber extends SocketSubscriber {
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  A **SocketEventSubscriber** listens for event logs.
+ */
+export declare class SocketEventSubscriber extends SocketSubscriber {
+    #private;
+    /**
+     *  The filter.
+     */
+    get logFilter(): EventFilter;
+    /**
+     *  @_ignore:
+     */
+    constructor(provider: SocketProvider, filter: EventFilter);
+    _emit(provider: SocketProvider, message: any): Promise<void>;
+}
+/**
+ *  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 declare class SocketProvider extends JsonRpcApiProvider {
+    #private;
+    requestTimeoutSeconds: number;
+    /**
+     *  Creates a new **SocketProvider** connected to %%network%%.
+     *
+     *  If unspecified, the network will be discovered.
+     */
+    constructor(network?: Networkish, _options?: JsonRpcApiProviderOptions);
+    _getSubscriber(sub: Subscription): Subscriber;
+    /**
+     *  Register a new subscriber. This is used internalled by Subscribers
+     *  and generally is unecessary unless extending capabilities.
+     */
+    _register(filterId: number | string, subscriber: SocketSubscriber): void;
+    _send(payload: JsonRpcPayload | Array<JsonRpcPayload>): Promise<Array<JsonRpcResult | JsonRpcError>>;
+    _connected(): void;
+    _disconnected(): void;
+    /**
+     *  Sub-classes **must** call this with messages received over their
+     *  transport to be processed and dispatched.
+     */
+    _processMessage(message: string): Promise<void>;
+    /**
+     *  Sub-classes **must** override this to send %%message%% over their
+     *  transport.
+     */
+    _write(message: string): Promise<void>;
+}