@atomiqlabs/chain-starknet 8.0.13 → 8.1.10

package/dist/starknet/provider/RpcProviderWithRetries.d.ts

@@ -1,53 +1,49 @@
-import { RPC09, RPC010, RpcProvider, RpcProviderOptions } from "starknet";
-/**
- * @private
- */
-export declare class Rpc09ChannelWithRetries extends RPC09.RpcChannel {
-    readonly retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    };
-    constructor(options?: RpcProviderOptions, retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    });
-    protected fetchEndpoint(method: any, params?: any): Promise<any>;
-}
-/**
- * @private
- */
-export declare class Rpc010ChannelWithRetries extends RPC010.RpcChannel {
-    readonly retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    };
-    constructor(options?: RpcProviderOptions, retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    });
-    protected fetchEndpoint(method: any, params?: any): Promise<any>;
-}
-/**
- * An RPC provider with built-in retry functionality, retries calls to the RPC service on failure
- *
- * @category Providers
- */
-export declare class RpcProviderWithRetries extends RpcProvider {
-    /**
-     * Creates a new RPC provider which retries RPC calls on failure, controlled by the passed `retryPolicy`
-     * NOTE: Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `options.specVersion`
-     *  in the options!
-     *
-     * @param options
-     * @param retryPolicy
-     */
-    constructor(options?: RpcProviderOptions, retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    });
-}
+import { RPC09, RPC010, RpcProvider, RpcProviderOptions } from "starknet";
+/**
+ * @private
+ */
+export declare class Rpc09ChannelWithRetries extends RPC09.RpcChannel {
+    private readonly retryPolicy?;
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    });
+    protected fetchEndpoint(method: any, params?: any): Promise<any>;
+}
+/**
+ * @private
+ */
+export declare class Rpc010ChannelWithRetries extends RPC010.RpcChannel {
+    readonly retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    };
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    });
+    protected fetchEndpoint(method: any, params?: any): Promise<any>;
+}
+/**
+ * An RPC provider with built-in retry functionality, retries calls to the RPC service on failure
+ *
+ * @category Providers
+ */
+export declare class RpcProviderWithRetries extends RpcProvider {
+    /**
+     * Creates a new RPC provider which retries RPC calls on failure, controlled by the passed `retryPolicy`
+     * NOTE: Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `options.specVersion`
+     *  in the options!
+     *
+     * @param options
+     * @param retryPolicy
+     */
+    constructor(options?: RpcProviderOptions, retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    });
+}

package/dist/starknet/provider/RpcProviderWithRetries.js

@@ -1,94 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcProviderWithRetries = exports.Rpc010ChannelWithRetries = exports.Rpc09ChannelWithRetries = void 0;
-const starknet_1 = require("starknet");
-const Utils_1 = require("../../utils/Utils");
-/**
- * @private
- */
-class Rpc09ChannelWithRetries extends starknet_1.RPC09.RpcChannel {
-    constructor(options, retryPolicy) {
-        super(options);
-        this.retryPolicy = retryPolicy;
-    }
-    fetchEndpoint(method, params) {
-        return (0, Utils_1.tryWithRetries)(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
-            if (!e.message.startsWith("RPC: "))
-                return false;
-            if (e.message.includes("Unsupported method"))
-                return true;
-            const arr = e.message.split("\n");
-            const errorCode = parseInt(arr[arr.length - 1]);
-            if (isNaN(errorCode))
-                return false;
-            if (errorCode < 0)
-                return false; //Not defined error, e.g. Rate limit (-32097)
-            return true;
-        });
-    }
-}
-exports.Rpc09ChannelWithRetries = Rpc09ChannelWithRetries;
-/**
- * @private
- */
-class Rpc010ChannelWithRetries extends starknet_1.RPC010.RpcChannel {
-    constructor(options, retryPolicy) {
-        super(options);
-        this.retryPolicy = retryPolicy;
-    }
-    fetchEndpoint(method, params) {
-        return (0, Utils_1.tryWithRetries)(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
-            if (!e.message.startsWith("RPC: "))
-                return false;
-            if (e.message.includes("Unsupported method"))
-                return true;
-            const arr = e.message.split("\n");
-            const errorCode = parseInt(arr[arr.length - 1]);
-            if (isNaN(errorCode))
-                return false;
-            if (errorCode < 0)
-                return false; //Not defined error, e.g. Rate limit (-32097)
-            return true;
-        });
-    }
-}
-exports.Rpc010ChannelWithRetries = Rpc010ChannelWithRetries;
-/**
- * An RPC provider with built-in retry functionality, retries calls to the RPC service on failure
- *
- * @category Providers
- */
-class RpcProviderWithRetries extends starknet_1.RpcProvider {
-    /**
-     * Creates a new RPC provider which retries RPC calls on failure, controlled by the passed `retryPolicy`
-     * NOTE: Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `options.specVersion`
-     *  in the options!
-     *
-     * @param options
-     * @param retryPolicy
-     */
-    constructor(options, retryPolicy) {
-        options ?? (options = {});
-        if (options.specVersion == null) {
-            // Default to RPC 0.10.0 (starknetjs v9 default), fallback to 0.9.0 if URL indicates v0_9
-            if (options.nodeUrl?.endsWith("v0_9")) {
-                options.specVersion = "0.9.0";
-            }
-            else {
-                // Default to 0.10.0 for v9
-                options.specVersion = "0.10.0";
-            }
-        }
-        super(options);
-        const channelId = this.channel.id;
-        if (channelId === "RPC090") {
-            this.channel = new Rpc09ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
-        }
-        else if (channelId === "RPC0100" || channelId === "RPC010" || channelId === "RPC0.10.0" || (channelId && !channelId.startsWith("RPC08"))) {
-            // Handle RPC 0.10 (default in starknetjs v9) - channel ID might be "RPC0100", "RPC010", or other format
-            // Also handle any non-RPC08/RPC09 channel as RPC 0.10
-            this.channel = new Rpc010ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
-        }
-    }
-}
-exports.RpcProviderWithRetries = RpcProviderWithRetries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcProviderWithRetries = exports.Rpc010ChannelWithRetries = exports.Rpc09ChannelWithRetries = void 0;
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../utils/Utils");
+/**
+ * @private
+ */
+class Rpc09ChannelWithRetries extends starknet_1.RPC09.RpcChannel {
+    constructor(options, retryPolicy) {
+        super(options);
+        this.retryPolicy = retryPolicy;
+    }
+    fetchEndpoint(method, params) {
+        return (0, Utils_1.tryWithRetries)(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
+            if (!e.message.startsWith("RPC: "))
+                return false;
+            if (e.message.includes("Unsupported method"))
+                return true;
+            const arr = e.message.split("\n");
+            const errorCode = parseInt(arr[arr.length - 1]);
+            if (isNaN(errorCode))
+                return false;
+            if (errorCode < 0)
+                return false; //Not defined error, e.g. Rate limit (-32097)
+            return true;
+        });
+    }
+}
+exports.Rpc09ChannelWithRetries = Rpc09ChannelWithRetries;
+/**
+ * @private
+ */
+class Rpc010ChannelWithRetries extends starknet_1.RPC010.RpcChannel {
+    constructor(options, retryPolicy) {
+        super(options);
+        this.retryPolicy = retryPolicy;
+    }
+    fetchEndpoint(method, params) {
+        return (0, Utils_1.tryWithRetries)(() => super.fetchEndpoint(method, params), this.retryPolicy, e => {
+            if (!e.message.startsWith("RPC: "))
+                return false;
+            if (e.message.includes("Unsupported method"))
+                return true;
+            const arr = e.message.split("\n");
+            const errorCode = parseInt(arr[arr.length - 1]);
+            if (isNaN(errorCode))
+                return false;
+            if (errorCode < 0)
+                return false; //Not defined error, e.g. Rate limit (-32097)
+            return true;
+        });
+    }
+}
+exports.Rpc010ChannelWithRetries = Rpc010ChannelWithRetries;
+/**
+ * An RPC provider with built-in retry functionality, retries calls to the RPC service on failure
+ *
+ * @category Providers
+ */
+class RpcProviderWithRetries extends starknet_1.RpcProvider {
+    /**
+     * Creates a new RPC provider which retries RPC calls on failure, controlled by the passed `retryPolicy`
+     * NOTE: Tries to do naive detection of the spec version based on the suffix of nodeUrl, better pass the `options.specVersion`
+     *  in the options!
+     *
+     * @param options
+     * @param retryPolicy
+     */
+    constructor(options, retryPolicy) {
+        options ?? (options = {});
+        if (options.specVersion == null) {
+            // Default to RPC 0.10.0 (starknetjs v9 default), fallback to 0.9.0 if URL indicates v0_9
+            if (options.nodeUrl?.endsWith("v0_9")) {
+                options.specVersion = "0.9.0";
+            }
+            else {
+                // Default to 0.10.0 for v9
+                options.specVersion = "0.10.0";
+            }
+        }
+        super(options);
+        const channelId = this.channel.id;
+        if (channelId === "RPC090") {
+            this.channel = new Rpc09ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        }
+        else if (channelId === "RPC0100" || channelId === "RPC010" || channelId === "RPC0.10.0" || (channelId && !channelId.startsWith("RPC08"))) {
+            // Handle RPC 0.10 (default in starknetjs v9) - channel ID might be "RPC0100", "RPC010", or other format
+            // Also handle any non-RPC08/RPC09 channel as RPC 0.10
+            this.channel = new Rpc010ChannelWithRetries({ ...options, waitMode: false }, retryPolicy);
+        }
+    }
+}
+exports.RpcProviderWithRetries = RpcProviderWithRetries;

package/dist/starknet/provider/WebSocketChannelWithRetries.d.ts

@@ -1,21 +1,21 @@
-import { WebSocketChannel, WebSocketOptions } from "starknet";
-/**
- * An impl of WebSocketChannel which override the default exponential backoff and makes it linear
- * Also adds connection timeouts and retries if the initial connection fails. Retries indefinitely!
- *
- * @category Providers
- */
-export declare class WebSocketChannelWithRetries extends WebSocketChannel {
-    private connectionTimeout;
-    private connectionTimeoutMs;
-    /**
-     * Creates a new websocket channel, you can pass an additional `options.connectionTimeoutMs` param, which
-     *  defines a connection timeout, after the timeout the connection is re-attempted
-     *
-     * @param options
-     */
-    constructor(options: WebSocketOptions & {
-        connectionTimeoutMs?: number;
-    });
-    reconnect(): void;
-}
+import { WebSocketChannel, WebSocketOptions } from "starknet";
+/**
+ * An impl of WebSocketChannel which override the default exponential backoff and makes it linear
+ * Also adds connection timeouts and retries if the initial connection fails. Retries indefinitely!
+ *
+ * @category Providers
+ */
+export declare class WebSocketChannelWithRetries extends WebSocketChannel {
+    private connectionTimeout;
+    private connectionTimeoutMs;
+    /**
+     * Creates a new websocket channel, you can pass an additional `options.connectionTimeoutMs` param, which
+     *  defines a connection timeout, after the timeout the connection is re-attempted
+     *
+     * @param options
+     */
+    constructor(options: WebSocketOptions & {
+        connectionTimeoutMs?: number;
+    });
+    reconnect(): void;
+}

package/dist/starknet/provider/WebSocketChannelWithRetries.js

@@ -1,46 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketChannelWithRetries = void 0;
-const starknet_1 = require("starknet");
-/**
- * An impl of WebSocketChannel which override the default exponential backoff and makes it linear
- * Also adds connection timeouts and retries if the initial connection fails. Retries indefinitely!
- *
- * @category Providers
- */
-class WebSocketChannelWithRetries extends starknet_1.WebSocketChannel {
-    /**
-     * Creates a new websocket channel, you can pass an additional `options.connectionTimeoutMs` param, which
-     *  defines a connection timeout, after the timeout the connection is re-attempted
-     *
-     * @param options
-     */
-    constructor(options) {
-        super(options);
-        this.connectionTimeoutMs = options.connectionTimeoutMs ?? 5 * 1000;
-        const websocket = this.websocket;
-        this.connectionTimeout = setTimeout(() => {
-            console.log(`WebSocketChannelWithRetries: ctor(): Connection not opened in ${this.connectionTimeoutMs}ms, closing...`);
-            websocket.close();
-        }, this.connectionTimeoutMs);
-        websocket.addEventListener("open", () => {
-            clearTimeout(this.connectionTimeout);
-            this._processRequestQueue();
-        });
-    }
-    reconnect() {
-        this.reconnectAttempts = 1;
-        super.reconnect();
-        if (this.connectionTimeout != null)
-            clearTimeout(this.connectionTimeout);
-        const websocket = this.websocket;
-        this.connectionTimeout = setTimeout(() => {
-            console.log(`WebSocketChannelWithRetries: reconnect(): Connection not opened in ${this.connectionTimeoutMs}ms, closing...`);
-            websocket.close();
-        }, this.connectionTimeoutMs);
-        websocket.addEventListener("open", () => {
-            clearTimeout(this.connectionTimeout);
-        });
-    }
-}
-exports.WebSocketChannelWithRetries = WebSocketChannelWithRetries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketChannelWithRetries = void 0;
+const starknet_1 = require("starknet");
+/**
+ * An impl of WebSocketChannel which override the default exponential backoff and makes it linear
+ * Also adds connection timeouts and retries if the initial connection fails. Retries indefinitely!
+ *
+ * @category Providers
+ */
+class WebSocketChannelWithRetries extends starknet_1.WebSocketChannel {
+    /**
+     * Creates a new websocket channel, you can pass an additional `options.connectionTimeoutMs` param, which
+     *  defines a connection timeout, after the timeout the connection is re-attempted
+     *
+     * @param options
+     */
+    constructor(options) {
+        super(options);
+        this.connectionTimeoutMs = options.connectionTimeoutMs ?? 5 * 1000;
+        const websocket = this.websocket;
+        this.connectionTimeout = setTimeout(() => {
+            console.log(`WebSocketChannelWithRetries: ctor(): Connection not opened in ${this.connectionTimeoutMs}ms, closing...`);
+            websocket.close();
+        }, this.connectionTimeoutMs);
+        websocket.addEventListener("open", () => {
+            clearTimeout(this.connectionTimeout);
+            this._processRequestQueue();
+        });
+    }
+    reconnect() {
+        this.reconnectAttempts = 1;
+        super.reconnect();
+        if (this.connectionTimeout != null)
+            clearTimeout(this.connectionTimeout);
+        const websocket = this.websocket;
+        this.connectionTimeout = setTimeout(() => {
+            console.log(`WebSocketChannelWithRetries: reconnect(): Connection not opened in ${this.connectionTimeoutMs}ms, closing...`);
+            websocket.close();
+        }, this.connectionTimeoutMs);
+        websocket.addEventListener("open", () => {
+            clearTimeout(this.connectionTimeout);
+        });
+    }
+}
+exports.WebSocketChannelWithRetries = WebSocketChannelWithRetries;