@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/src/solana/connection/ConnectionWithRetries.ts

@@ -1,96 +1,113 @@
-import {Commitment, Connection, ConnectionConfig} from "@solana/web3.js";
-import {tryWithRetries} from "../../utils/Utils";
-
-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 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) {
-        let config: ConnectionWithRetriesConfig;
-        if(typeof(commitmentOrConfig)==="string") {
-            config = {commitment: commitmentOrConfig};
-        } else {
-            config = commitmentOrConfig ?? {};
-        }
-
-        config.fetch = (input: RequestInfo | URL, init?: RequestInit) => tryWithRetries(
-            async () => {
-                let timedOut = false;
-                const abortController = new AbortController();
-                const timeoutHandle = setTimeout(() => {
-                    timedOut = true;
-                    abortController.abort('Timed out');
-                }, this.requestTimeout);
-                let originalSignal: AbortSignal | undefined;
-                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: any) => {
-                    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;
-    }
-
-}
+import {Commitment, Connection, ConnectionConfig} from "@solana/web3.js";
+import {tryWithRetries} from "../../utils/Utils";
+
+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 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) {
+        let config: ConnectionWithRetriesConfig;
+        if(typeof(commitmentOrConfig)==="string") {
+            config = {commitment: commitmentOrConfig};
+        } else {
+            config = commitmentOrConfig ?? {};
+        }
+
+        config.fetch = (input: RequestInfo | URL, init?: RequestInit) => 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: AbortSignal | undefined;
+                let originalSignalListener: (() => void) | undefined;
+                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;
+    }
+
+}

package/src/solana/events/SolanaChainEvents.ts

@@ -1,127 +1,127 @@
-import {Connection} from "@solana/web3.js";
-import * as fs from "fs/promises";
-import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
-import {
-    SolanaChainEventsBrowser,
-    SolanaEventListenerState,
-    SolanaLegacyEventListenerState
-} from "./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
- */
-export class SolanaChainEvents extends SolanaChainEventsBrowser {
-
-    private readonly directory: string;
-    private readonly logFetchInterval: number;
-
-    private stopped: boolean = true;
-    private timeout?: NodeJS.Timeout;
-
-    constructor(
-        directory: string,
-        connection: Connection,
-        contractVersions: SolanaSwapProgram | {[version: string]: {swapContract: SolanaSwapProgram}},
-        logFetchInterval?: number
-    ) {
-        super(connection, contractVersions);
-        this.directory = directory;
-        this.logFetchInterval = logFetchInterval || LOG_FETCH_INTERVAL;
-    }
-
-    /**
-     * Retrieves last signature & slot from filesystem
-     *
-     * @private
-     */
-    private async getLastSignature(): Promise<SolanaLegacyEventListenerState | SolanaEventListenerState | null> {
-        let txt: string;
-        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
-     */
-    private saveLastSignature(lastState: SolanaEventListenerState): Promise<void> {
-        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, JSON.stringify(lastState));
-    }
-
-    /**
-     * Polls for new events & processes them
-     *
-     * @private
-     */
-    private async checkEvents() {
-        const lastSignature = await this.getLastSignature();
-
-        const result = await this.poll(lastSignature ?? undefined);
-
-        if(result!=null) {
-            await this.saveLastSignature(result);
-        }
-    }
-
-    private async setupHttpPolling() {
-        this.stopped = false;
-        let func: () => Promise<void>;
-        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?: boolean): Promise<void> {
-        if(noAutomaticPoll) return;
-        try {
-            await fs.mkdir(this.directory);
-        } catch (e) {}
-
-        await this.setupHttpPolling();
-        this.setupWebsocket();
-    }
-
-    /**
-     * @inheritDoc
-     */
-    stop(): Promise<void> {
-        this.stopped = true;
-        if(this.timeout!=null) clearTimeout(this.timeout)
-        return super.stop();
-    }
-
-}
+import {Connection} from "@solana/web3.js";
+import * as fs from "fs/promises";
+import {SolanaSwapProgram} from "../swaps/SolanaSwapProgram";
+import {
+    SolanaChainEventsBrowser,
+    SolanaEventListenerState,
+    SolanaLegacyEventListenerState
+} from "./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
+ */
+export class SolanaChainEvents extends SolanaChainEventsBrowser {
+
+    private readonly directory: string;
+    private readonly logFetchInterval: number;
+
+    private stopped: boolean = true;
+    private timeout?: NodeJS.Timeout;
+
+    constructor(
+        directory: string,
+        connection: Connection,
+        contractVersions: SolanaSwapProgram | {[version: string]: {swapContract: SolanaSwapProgram}},
+        logFetchInterval?: number
+    ) {
+        super(connection, contractVersions);
+        this.directory = directory;
+        this.logFetchInterval = logFetchInterval || LOG_FETCH_INTERVAL;
+    }
+
+    /**
+     * Retrieves last signature & slot from filesystem
+     *
+     * @private
+     */
+    private async getLastSignature(): Promise<SolanaLegacyEventListenerState | SolanaEventListenerState | null> {
+        let txt: string;
+        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
+     */
+    private saveLastSignature(lastState: SolanaEventListenerState): Promise<void> {
+        return fs.writeFile(this.directory+BLOCKHEIGHT_FILENAME, JSON.stringify(lastState));
+    }
+
+    /**
+     * Polls for new events & processes them
+     *
+     * @private
+     */
+    private async checkEvents() {
+        const lastSignature = await this.getLastSignature();
+
+        const result = await this.poll(lastSignature ?? undefined);
+
+        if(result!=null) {
+            await this.saveLastSignature(result);
+        }
+    }
+
+    private async setupHttpPolling() {
+        this.stopped = false;
+        let func: () => Promise<void>;
+        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?: boolean): Promise<void> {
+        if(noAutomaticPoll) return;
+        try {
+            await fs.mkdir(this.directory);
+        } catch (e) {}
+
+        await this.setupHttpPolling();
+        this.setupWebsocket();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    stop(): Promise<void> {
+        this.stopped = true;
+        if(this.timeout!=null) clearTimeout(this.timeout)
+        return super.stop();
+    }
+
+}