@atomiqlabs/chain-solana 13.5.13 → 13.5.14

package/dist/solana/chain/modules/SolanaBlocks.d.ts

@@ -1,32 +1,32 @@
-import { SolanaModule } from "../SolanaModule";
-import { Finality, ParsedAccountsModeBlockResponse } from "@solana/web3.js";
-export type BlockChecked = ParsedAccountsModeBlockResponse & {
-    blockTime: number;
-    blockHeight: number;
-};
-export declare class SolanaBlocks extends SolanaModule {
-    private blockCache;
-    /**
-     * Initiates a fetch of the block at specified slot & saves the fetch promise into a block cache
-     *
-     * @param slot
-     * @private
-     */
-    private fetchAndSaveParsedBlock;
-    /**
-     * Tries to find the latest existing block for a given commitment, skipping blocks that are not available, runs a
-     *  search backwards from the latest slot for the given commitment and fails after 10 tries
-     *
-     * @param commitment
-     */
-    findLatestParsedBlock(commitment: Finality): Promise<{
-        block: BlockChecked;
-        slot: number;
-    }>;
-    /**
-     * Gets parsed block for a given slot, uses block cache if the block was already fetched before
-     *
-     * @param slot
-     */
-    getParsedBlock(slot: number): Promise<BlockChecked>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { Finality, ParsedAccountsModeBlockResponse } from "@solana/web3.js";
+export type BlockChecked = ParsedAccountsModeBlockResponse & {
+    blockTime: number;
+    blockHeight: number;
+};
+export declare class SolanaBlocks extends SolanaModule {
+    private blockCache;
+    /**
+     * Initiates a fetch of the block at specified slot & saves the fetch promise into a block cache
+     *
+     * @param slot
+     * @private
+     */
+    private fetchAndSaveParsedBlock;
+    /**
+     * Tries to find the latest existing block for a given commitment, skipping blocks that are not available, runs a
+     *  search backwards from the latest slot for the given commitment and fails after 10 tries
+     *
+     * @param commitment
+     */
+    findLatestParsedBlock(commitment: Finality): Promise<{
+        block: BlockChecked;
+        slot: number;
+    }>;
+    /**
+     * Gets parsed block for a given slot, uses block cache if the block was already fetched before
+     *
+     * @param slot
+     */
+    getParsedBlock(slot: number): Promise<BlockChecked>;
+}

package/dist/solana/chain/modules/SolanaBlocks.js

@@ -1,78 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaBlocks = void 0;
-const SolanaModule_1 = require("../SolanaModule");
-class SolanaBlocks extends SolanaModule_1.SolanaModule {
-    constructor() {
-        super(...arguments);
-        this.blockCache = new Map();
-    }
-    /**
-     * Initiates a fetch of the block at specified slot & saves the fetch promise into a block cache
-     *
-     * @param slot
-     * @private
-     */
-    fetchAndSaveParsedBlock(slot) {
-        const blockCacheData = this.connection.getParsedBlock(slot, {
-            transactionDetails: "none",
-            commitment: "confirmed",
-            rewards: false
-        }).then(val => {
-            if (val.blockHeight == null || val.blockTime == null)
-                throw new Error(`Cannot get block for slot ${slot}: blockHeight or blockTime empty!`);
-            return val;
-        });
-        this.blockCache.set(slot, blockCacheData);
-        blockCacheData.catch(() => {
-            if (this.blockCache.get(slot) == blockCacheData)
-                this.blockCache.delete(slot);
-        });
-        return blockCacheData;
-    }
-    ///////////////////
-    //// Blocks
-    /**
-     * Tries to find the latest existing block for a given commitment, skipping blocks that are not available, runs a
-     *  search backwards from the latest slot for the given commitment and fails after 10 tries
-     *
-     * @param commitment
-     */
-    async findLatestParsedBlock(commitment) {
-        let slot = await this.root.Slots.getSlot(commitment);
-        for (let i = 0; i < 16; i++) {
-            const block = await this.getParsedBlock(slot).catch(e => {
-                const errorStr = e.toString();
-                if (errorStr.startsWith("SolanaJSONRPCError: failed to get block:") && (errorStr.includes("Block not available for slot") ||
-                    errorStr.includes("was skipped") ||
-                    errorStr.includes("missing in long-term storage"))) {
-                    return null;
-                }
-                throw e;
-            });
-            if (block != null) {
-                this.logger.debug("findLatestParsedBlock(): Found valid block, slot: " + slot +
-                    " blockhash: " + block.blockhash + " tries: " + i);
-                return {
-                    block,
-                    slot
-                };
-            }
-            slot--;
-        }
-        throw new Error(`Ran out of tries trying to find a parsedBlock, last attempted slot: ${slot + 1}`);
-    }
-    /**
-     * Gets parsed block for a given slot, uses block cache if the block was already fetched before
-     *
-     * @param slot
-     */
-    getParsedBlock(slot) {
-        let blockCacheData = this.blockCache.get(slot);
-        if (blockCacheData == null) {
-            blockCacheData = this.fetchAndSaveParsedBlock(slot);
-        }
-        return blockCacheData;
-    }
-}
-exports.SolanaBlocks = SolanaBlocks;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaBlocks = void 0;
+const SolanaModule_1 = require("../SolanaModule");
+class SolanaBlocks extends SolanaModule_1.SolanaModule {
+    constructor() {
+        super(...arguments);
+        this.blockCache = new Map();
+    }
+    /**
+     * Initiates a fetch of the block at specified slot & saves the fetch promise into a block cache
+     *
+     * @param slot
+     * @private
+     */
+    fetchAndSaveParsedBlock(slot) {
+        const blockCacheData = this.connection.getParsedBlock(slot, {
+            transactionDetails: "none",
+            commitment: "confirmed",
+            rewards: false
+        }).then(val => {
+            if (val.blockHeight == null || val.blockTime == null)
+                throw new Error(`Cannot get block for slot ${slot}: blockHeight or blockTime empty!`);
+            return val;
+        });
+        this.blockCache.set(slot, blockCacheData);
+        blockCacheData.catch(() => {
+            if (this.blockCache.get(slot) == blockCacheData)
+                this.blockCache.delete(slot);
+        });
+        return blockCacheData;
+    }
+    ///////////////////
+    //// Blocks
+    /**
+     * Tries to find the latest existing block for a given commitment, skipping blocks that are not available, runs a
+     *  search backwards from the latest slot for the given commitment and fails after 10 tries
+     *
+     * @param commitment
+     */
+    async findLatestParsedBlock(commitment) {
+        let slot = await this.root.Slots.getSlot(commitment);
+        for (let i = 0; i < 16; i++) {
+            const block = await this.getParsedBlock(slot).catch(e => {
+                const errorStr = e.toString();
+                if (errorStr.startsWith("SolanaJSONRPCError: failed to get block:") && (errorStr.includes("Block not available for slot") ||
+                    errorStr.includes("was skipped") ||
+                    errorStr.includes("missing in long-term storage"))) {
+                    return null;
+                }
+                throw e;
+            });
+            if (block != null) {
+                this.logger.debug("findLatestParsedBlock(): Found valid block, slot: " + slot +
+                    " blockhash: " + block.blockhash + " tries: " + i);
+                return {
+                    block,
+                    slot
+                };
+            }
+            slot--;
+        }
+        throw new Error(`Ran out of tries trying to find a parsedBlock, last attempted slot: ${slot + 1}`);
+    }
+    /**
+     * Gets parsed block for a given slot, uses block cache if the block was already fetched before
+     *
+     * @param slot
+     */
+    getParsedBlock(slot) {
+        let blockCacheData = this.blockCache.get(slot);
+        if (blockCacheData == null) {
+            blockCacheData = this.fetchAndSaveParsedBlock(slot);
+        }
+        return blockCacheData;
+    }
+}
+exports.SolanaBlocks = SolanaBlocks;

package/dist/solana/chain/modules/SolanaEvents.d.ts

@@ -1,68 +1,68 @@
-import { SolanaModule } from "../SolanaModule";
-import { ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
-export declare class SolanaEvents extends SolanaModule {
-    readonly LOG_FETCH_LIMIT = 500;
-    private usingHeliusTFA;
-    /**
-     * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
-     *  the signatures before this signature
-     *
-     * @param topicKey
-     * @param logFetchLimit
-     * @param lastProcessedSignature
-     * @private
-     */
-    private getSignatures;
-    /**
-     * Implements Helius getTransactionsForAddress RPC API
-     *
-     * @param account
-     * @param options
-     * @param commitment
-     */
-    getTransactionsForAddress(account: PublicKey, options?: {
-        paginationToken?: string;
-        filters?: {
-            slot?: {
-                gte?: number;
-                lte?: number;
-                gt?: number;
-                lt?: number;
-            };
-            blockTime?: {
-                gte?: number;
-                lte?: number;
-                gt?: number;
-                lt?: number;
-                eq?: number;
-            };
-            signature?: {
-                gte?: number;
-                lte?: number;
-                gt?: number;
-                lt?: number;
-                eq?: number;
-            };
-            status?: "succeeded" | "failed" | "any";
-        };
-    }, commitment?: "finalized" | "confirmed" | "processed"): Promise<{
-        data: ParsedTransactionWithMeta[];
-        paginationToken?: string;
-    } | null>;
-    private _findInTxsTFA;
-    /**
-     * Runs a search backwards in time, processing transaction signatures for a specific topic public key
-     *
-     * @param topicKey
-     * @param processor called for every batch of returned signatures, should return a value if the correct signature
-     *  was found, or null if the search should continue
-     * @param abortSignal
-     * @param logFetchLimit
-     * @param startBlockheight
-     */
-    private _findInSignatures;
-    findInSignatures<T>(topicKey: PublicKey, processor: (data: {
-        signatures?: ConfirmedSignatureInfo[];
-        txs?: ParsedTransactionWithMeta[];
-    }) => Promise<T | undefined | null>, abortSignal?: AbortSignal, logFetchLimit?: number, startBlockheight?: number): Promise<T | null>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { ConfirmedSignatureInfo, ParsedTransactionWithMeta, PublicKey } from "@solana/web3.js";
+export declare class SolanaEvents extends SolanaModule {
+    readonly LOG_FETCH_LIMIT = 500;
+    private usingHeliusTFA;
+    /**
+     * Gets the signatures for a given topicKey public key, if lastProcessedSignature is specified, it fetches only
+     *  the signatures before this signature
+     *
+     * @param topicKey
+     * @param logFetchLimit
+     * @param lastProcessedSignature
+     * @private
+     */
+    private getSignatures;
+    /**
+     * Implements Helius getTransactionsForAddress RPC API
+     *
+     * @param account
+     * @param options
+     * @param commitment
+     */
+    getTransactionsForAddress(account: PublicKey, options?: {
+        paginationToken?: string;
+        filters?: {
+            slot?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+            };
+            blockTime?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            signature?: {
+                gte?: number;
+                lte?: number;
+                gt?: number;
+                lt?: number;
+                eq?: number;
+            };
+            status?: "succeeded" | "failed" | "any";
+        };
+    }, commitment?: "finalized" | "confirmed" | "processed"): Promise<{
+        data: ParsedTransactionWithMeta[];
+        paginationToken?: string;
+    } | null>;
+    private _findInTxsTFA;
+    /**
+     * Runs a search backwards in time, processing transaction signatures for a specific topic public key
+     *
+     * @param topicKey
+     * @param processor called for every batch of returned signatures, should return a value if the correct signature
+     *  was found, or null if the search should continue
+     * @param abortSignal
+     * @param logFetchLimit
+     * @param startBlockheight
+     */
+    private _findInSignatures;
+    findInSignatures<T>(topicKey: PublicKey, processor: (data: {
+        signatures?: ConfirmedSignatureInfo[];
+        txs?: ParsedTransactionWithMeta[];
+    }) => Promise<T | undefined | null>, abortSignal?: AbortSignal, logFetchLimit?: number, startBlockheight?: number): Promise<T | null>;
+}