@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/dist/solana/connection/ConnectionWithRetries.d.ts

@@ -1,35 +1,35 @@
-import { Commitment, Connection, ConnectionConfig } from "@solana/web3.js";
-export type ConnectionWithRetriesConfig = ConnectionConfig & {
-    retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    };
-    requestTimeout?: number;
-};
-/**
- * Solana connection with retry logic and request timeout handling for RPC calls.
- *
- * @category Providers
- */
-export declare class ConnectionWithRetries extends Connection {
-    /**
-     * Retry policy used for RPC requests.
-     */
-    readonly retryPolicy?: {
-        maxRetries?: number;
-        delay?: number;
-        exponential?: boolean;
-    };
-    /**
-     * Per-request timeout in milliseconds.
-     */
-    readonly requestTimeout: number;
-    /**
-     * Constructs a retry-enabled Solana connection.
-     *
-     * @param endpoint RPC endpoint URL
-     * @param commitmentOrConfig Commitment level or full connection configuration
-     */
-    constructor(endpoint: string, commitmentOrConfig?: Commitment | ConnectionWithRetriesConfig);
-}
+import { Commitment, Connection, ConnectionConfig } from "@solana/web3.js";
+export type ConnectionWithRetriesConfig = ConnectionConfig & {
+    retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    };
+    requestTimeout?: number;
+};
+/**
+ * Solana connection with retry logic and request timeout handling for RPC calls.
+ *
+ * @category Providers
+ */
+export declare class ConnectionWithRetries extends Connection {
+    /**
+     * Retry policy used for RPC requests.
+     */
+    readonly retryPolicy?: {
+        maxRetries?: number;
+        delay?: number;
+        exponential?: boolean;
+    };
+    /**
+     * Per-request timeout in milliseconds.
+     */
+    readonly requestTimeout: number;
+    /**
+     * Constructs a retry-enabled Solana connection.
+     *
+     * @param endpoint RPC endpoint URL
+     * @param commitmentOrConfig Commitment level or full connection configuration
+     */
+    constructor(endpoint: string, commitmentOrConfig?: Commitment | ConnectionWithRetriesConfig);
+}

package/dist/solana/connection/ConnectionWithRetries.js

@@ -1,71 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionWithRetries = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const Utils_1 = require("../../utils/Utils");
-/**
- * Solana connection with retry logic and request timeout handling for RPC calls.
- *
- * @category Providers
- */
-class ConnectionWithRetries extends web3_js_1.Connection {
-    /**
-     * Constructs a retry-enabled Solana connection.
-     *
-     * @param endpoint RPC endpoint URL
-     * @param commitmentOrConfig Commitment level or full connection configuration
-     */
-    constructor(endpoint, commitmentOrConfig) {
-        let config;
-        if (typeof (commitmentOrConfig) === "string") {
-            config = { commitment: commitmentOrConfig };
-        }
-        else {
-            config = commitmentOrConfig ?? {};
-        }
-        config.fetch = (input, init) => (0, Utils_1.tryWithRetries)(async () => {
-            let timedOut = false;
-            const abortController = new AbortController();
-            const timeoutHandle = setTimeout(() => {
-                timedOut = true;
-                abortController.abort('Timed out');
-            }, this.requestTimeout);
-            let originalSignal;
-            if (init?.signal != null) {
-                originalSignal = init.signal;
-                init.signal.addEventListener('abort', (reason) => {
-                    clearTimeout(timeoutHandle);
-                    abortController.abort(reason);
-                });
-            }
-            const result = await fetch(input, {
-                ...init,
-                signal: abortController.signal
-            }).catch((e) => {
-                console.error('SolanaWalletProvider: fetchWithTimeout(' + typeof e + '): ', e);
-                if (e.name === 'AbortError' &&
-                    (originalSignal == null || !originalSignal.aborted) &&
-                    timedOut) {
-                    throw new Error('Network request timed out');
-                }
-                else {
-                    throw e;
-                }
-            });
-            if (Math.floor(result.status / 100) === 5) {
-                throw new Error(`Internal server error: ${result.status}`);
-            }
-            if (result.status === 429) {
-                throw new Error(`Too many requests (429)`);
-            }
-            return result;
-        }, this.retryPolicy, (e) => !e?.message?.startsWith?.("Internal server error: ") &&
-            e?.message !== "Network request timed out" &&
-            e?.message !== "Too many requests (429)", init?.signal ?? undefined);
-        config.disableRetryOnRateLimit = true;
-        super(endpoint, config);
-        this.retryPolicy = config?.retryPolicy;
-        this.requestTimeout = config?.requestTimeout ?? 15 * 1000;
-    }
-}
-exports.ConnectionWithRetries = ConnectionWithRetries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionWithRetries = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Utils_1 = require("../../utils/Utils");
+/**
+ * Solana connection with retry logic and request timeout handling for RPC calls.
+ *
+ * @category Providers
+ */
+class ConnectionWithRetries extends web3_js_1.Connection {
+    /**
+     * Constructs a retry-enabled Solana connection.
+     *
+     * @param endpoint RPC endpoint URL
+     * @param commitmentOrConfig Commitment level or full connection configuration
+     */
+    constructor(endpoint, commitmentOrConfig) {
+        let config;
+        if (typeof (commitmentOrConfig) === "string") {
+            config = { commitment: commitmentOrConfig };
+        }
+        else {
+            config = commitmentOrConfig ?? {};
+        }
+        config.fetch = (input, init) => (0, Utils_1.tryWithRetries)(async () => {
+            if (init?.signal?.aborted) {
+                throw init.signal.reason instanceof Error
+                    ? init.signal.reason
+                    : new Error("Aborted");
+            }
+            const abortController = new AbortController();
+            const timeoutHandle = setTimeout(() => {
+                abortController.abort(new Error('Network request timed out'));
+            }, this.requestTimeout);
+            let originalSignal;
+            let originalSignalListener;
+            if (init?.signal != null) {
+                originalSignal = init.signal;
+                originalSignal.addEventListener('abort', originalSignalListener = () => {
+                    clearTimeout(timeoutHandle);
+                    abortController.abort(originalSignal?.reason instanceof Error
+                        ? originalSignal?.reason
+                        : new Error("Aborted"));
+                });
+            }
+            try {
+                const result = await fetch(input, {
+                    ...init,
+                    signal: abortController.signal
+                });
+                if (Math.floor(result.status / 100) === 5) {
+                    throw new Error(`Internal server error: ${result.status}`);
+                }
+                if (result.status === 429) {
+                    throw new Error(`Too many requests (429)`);
+                }
+                try {
+                    const textResult = await result.text();
+                    return new Response(textResult, {
+                        status: result.status,
+                        statusText: result.statusText,
+                        headers: result.headers,
+                    });
+                }
+                catch (e) {
+                    console.error(`ConnectionWithRetries: fetch(): Failed to read response body: `, e);
+                    throw new Error("Error reading response body");
+                }
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+                if (originalSignal != null && originalSignalListener != null)
+                    originalSignal.removeEventListener("abort", originalSignalListener);
+            }
+        }, this.retryPolicy, (e) => !e?.message?.startsWith?.("Internal server error: ") &&
+            e?.message !== "Network request timed out" &&
+            e?.message !== "Too many requests (429)" &&
+            e?.message !== "Error reading response body", init?.signal ?? undefined);
+        config.disableRetryOnRateLimit = true;
+        super(endpoint, config);
+        this.retryPolicy = config?.retryPolicy;
+        this.requestTimeout = config?.requestTimeout ?? 15 * 1000;
+    }
+}
+exports.ConnectionWithRetries = ConnectionWithRetries;

package/dist/solana/events/SolanaChainEvents.d.ts

@@ -1,45 +1,45 @@
-import { Connection } from "@solana/web3.js";
-import { SolanaSwapProgram } from "../swaps/SolanaSwapProgram";
-import { SolanaChainEventsBrowser } from "./SolanaChainEventsBrowser";
-/**
- * Event handler for backend Node.js systems with access to fs, uses HTTP polling in combination with WS to not miss
- *  any events
- */
-export declare class SolanaChainEvents extends SolanaChainEventsBrowser {
-    private readonly directory;
-    private readonly logFetchInterval;
-    private stopped;
-    private timeout?;
-    constructor(directory: string, connection: Connection, contractVersions: SolanaSwapProgram | {
-        [version: string]: {
-            swapContract: SolanaSwapProgram;
-        };
-    }, logFetchInterval?: number);
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private getLastSignature;
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    private saveLastSignature;
-    /**
-     * Polls for new events & processes them
-     *
-     * @private
-     */
-    private checkEvents;
-    private setupHttpPolling;
-    /**
-     * @inheritDoc
-     */
-    init(noAutomaticPoll?: boolean): Promise<void>;
-    /**
-     * @inheritDoc
-     */
-    stop(): Promise<void>;
-}
+import { Connection } from "@solana/web3.js";
+import { SolanaSwapProgram } from "../swaps/SolanaSwapProgram";
+import { SolanaChainEventsBrowser } from "./SolanaChainEventsBrowser";
+/**
+ * Event handler for backend Node.js systems with access to fs, uses HTTP polling in combination with WS to not miss
+ *  any events
+ */
+export declare class SolanaChainEvents extends SolanaChainEventsBrowser {
+    private readonly directory;
+    private readonly logFetchInterval;
+    private stopped;
+    private timeout?;
+    constructor(directory: string, connection: Connection, contractVersions: SolanaSwapProgram | {
+        [version: string]: {
+            swapContract: SolanaSwapProgram;
+        };
+    }, logFetchInterval?: number);
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private getLastSignature;
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    private saveLastSignature;
+    /**
+     * Polls for new events & processes them
+     *
+     * @private
+     */
+    private checkEvents;
+    private setupHttpPolling;
+    /**
+     * @inheritDoc
+     */
+    init(noAutomaticPoll?: boolean): Promise<void>;
+    /**
+     * @inheritDoc
+     */
+    stop(): Promise<void>;
+}

package/dist/solana/events/SolanaChainEvents.js

@@ -1,108 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaChainEvents = void 0;
-const fs = require("fs/promises");
-const SolanaChainEventsBrowser_1 = require("./SolanaChainEventsBrowser");
-const BLOCKHEIGHT_FILENAME = "/blockheight.txt";
-const LOG_FETCH_INTERVAL = 5 * 1000;
-/**
- * Event handler for backend Node.js systems with access to fs, uses HTTP polling in combination with WS to not miss
- *  any events
- */
-class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrowser {
-    constructor(directory, connection, contractVersions, logFetchInterval) {
-        super(connection, contractVersions);
-        this.stopped = true;
-        this.directory = directory;
-        this.logFetchInterval = logFetchInterval || LOG_FETCH_INTERVAL;
-    }
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    async getLastSignature() {
-        let txt;
-        try {
-            txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
-        }
-        catch (e) {
-            return null;
-        }
-        try {
-            return JSON.parse(txt);
-        }
-        catch (e) { }
-        try {
-            const arr = txt.split(";");
-            if (arr.length < 2)
-                return {
-                    signature: txt,
-                    slot: 0
-                };
-            return {
-                signature: arr[0],
-                slot: parseInt(arr[1])
-            };
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    /**
-     * Saves last signature & slot to the filesystem
-     *
-     * @private
-     */
-    saveLastSignature(lastState) {
-        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, JSON.stringify(lastState));
-    }
-    /**
-     * Polls for new events & processes them
-     *
-     * @private
-     */
-    async checkEvents() {
-        const lastSignature = await this.getLastSignature();
-        const result = await this.poll(lastSignature ?? undefined);
-        if (result != null) {
-            await this.saveLastSignature(result);
-        }
-    }
-    async setupHttpPolling() {
-        this.stopped = false;
-        let func;
-        func = async () => {
-            await this.checkEvents().catch(e => {
-                this.logger.error("setupHttpPolling(): Failed to fetch Solana log: ", e);
-            });
-            if (this.stopped)
-                return;
-            this.timeout = setTimeout(func, this.logFetchInterval);
-        };
-        await func();
-    }
-    /**
-     * @inheritDoc
-     */
-    async init(noAutomaticPoll) {
-        if (noAutomaticPoll)
-            return;
-        try {
-            await fs.mkdir(this.directory);
-        }
-        catch (e) { }
-        await this.setupHttpPolling();
-        this.setupWebsocket();
-    }
-    /**
-     * @inheritDoc
-     */
-    stop() {
-        this.stopped = true;
-        if (this.timeout != null)
-            clearTimeout(this.timeout);
-        return super.stop();
-    }
-}
-exports.SolanaChainEvents = SolanaChainEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaChainEvents = void 0;
+const fs = require("fs/promises");
+const SolanaChainEventsBrowser_1 = require("./SolanaChainEventsBrowser");
+const BLOCKHEIGHT_FILENAME = "/blockheight.txt";
+const LOG_FETCH_INTERVAL = 5 * 1000;
+/**
+ * Event handler for backend Node.js systems with access to fs, uses HTTP polling in combination with WS to not miss
+ *  any events
+ */
+class SolanaChainEvents extends SolanaChainEventsBrowser_1.SolanaChainEventsBrowser {
+    constructor(directory, connection, contractVersions, logFetchInterval) {
+        super(connection, contractVersions);
+        this.stopped = true;
+        this.directory = directory;
+        this.logFetchInterval = logFetchInterval || LOG_FETCH_INTERVAL;
+    }
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    async getLastSignature() {
+        let txt;
+        try {
+            txt = (await fs.readFile(this.directory + BLOCKHEIGHT_FILENAME)).toString();
+        }
+        catch (e) {
+            return null;
+        }
+        try {
+            return JSON.parse(txt);
+        }
+        catch (e) { }
+        try {
+            const arr = txt.split(";");
+            if (arr.length < 2)
+                return {
+                    signature: txt,
+                    slot: 0
+                };
+            return {
+                signature: arr[0],
+                slot: parseInt(arr[1])
+            };
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    /**
+     * Saves last signature & slot to the filesystem
+     *
+     * @private
+     */
+    saveLastSignature(lastState) {
+        return fs.writeFile(this.directory + BLOCKHEIGHT_FILENAME, JSON.stringify(lastState));
+    }
+    /**
+     * Polls for new events & processes them
+     *
+     * @private
+     */
+    async checkEvents() {
+        const lastSignature = await this.getLastSignature();
+        const result = await this.poll(lastSignature ?? undefined);
+        if (result != null) {
+            await this.saveLastSignature(result);
+        }
+    }
+    async setupHttpPolling() {
+        this.stopped = false;
+        let func;
+        func = async () => {
+            await this.checkEvents().catch(e => {
+                this.logger.error("setupHttpPolling(): Failed to fetch Solana log: ", e);
+            });
+            if (this.stopped)
+                return;
+            this.timeout = setTimeout(func, this.logFetchInterval);
+        };
+        await func();
+    }
+    /**
+     * @inheritDoc
+     */
+    async init(noAutomaticPoll) {
+        if (noAutomaticPoll)
+            return;
+        try {
+            await fs.mkdir(this.directory);
+        }
+        catch (e) { }
+        await this.setupHttpPolling();
+        this.setupWebsocket();
+    }
+    /**
+     * @inheritDoc
+     */
+    stop() {
+        this.stopped = true;
+        if (this.timeout != null)
+            clearTimeout(this.timeout);
+        return super.stop();
+    }
+}
+exports.SolanaChainEvents = SolanaChainEvents;