@atomiqlabs/chain-solana 10.0.0-dev.3 → 11.0.0

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

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAddresses = void 0;
-const web3_js_1 = require("@solana/web3.js");
-class SolanaAddresses {
-    ///////////////////
-    //// Address utils
-    /**
-     * Checks whether an address is a valid Solana address (base58 encoded ed25519 public key)
-     *
-     * @param address
-     */
-    static isValidAddress(address) {
-        try {
-            return web3_js_1.PublicKey.isOnCurve(address);
-        }
-        catch (e) {
-            return false;
-        }
-    }
-}
-exports.SolanaAddresses = SolanaAddresses;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAddresses = void 0;
+const web3_js_1 = require("@solana/web3.js");
+class SolanaAddresses {
+    ///////////////////
+    //// Address utils
+    /**
+     * Checks whether an address is a valid Solana address (base58 encoded ed25519 public key)
+     *
+     * @param address
+     */
+    static isValidAddress(address) {
+        try {
+            return web3_js_1.PublicKey.isOnCurve(address);
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.SolanaAddresses = SolanaAddresses;

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

@@ -1,28 +1,28 @@
-import { SolanaModule } from "../SolanaModule";
-import { Commitment, ParsedAccountsModeBlockResponse } from "@solana/web3.js";
-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: Commitment): Promise<{
-        block: ParsedAccountsModeBlockResponse;
-        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<ParsedAccountsModeBlockResponse>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { Commitment, ParsedAccountsModeBlockResponse } from "@solana/web3.js";
+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: Commitment): Promise<{
+        block: ParsedAccountsModeBlockResponse;
+        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<ParsedAccountsModeBlockResponse>;
+}

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

@@ -1,72 +1,72 @@
-"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
-        });
-        this.blockCache.set(slot, blockCacheData);
-        blockCacheData.catch(e => {
-            if (this.blockCache.get(slot) == blockCacheData)
-                this.blockCache.delete(slot);
-            throw e;
-        });
-        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 < 10; i++) {
-            const block = await this.getParsedBlock(slot).catch(e => {
-                if (e.toString().startsWith("SolanaJSONRPCError: failed to get block: Block not available for slot")) {
-                    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");
-    }
-    /**
-     * 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
+        });
+        this.blockCache.set(slot, blockCacheData);
+        blockCacheData.catch(e => {
+            if (this.blockCache.get(slot) == blockCacheData)
+                this.blockCache.delete(slot);
+            throw e;
+        });
+        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 < 10; i++) {
+            const block = await this.getParsedBlock(slot).catch(e => {
+                if (e.toString().startsWith("SolanaJSONRPCError: failed to get block: Block not available for slot")) {
+                    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");
+    }
+    /**
+     * 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,25 +1,25 @@
-import { SolanaModule } from "../SolanaModule";
-import { ConfirmedSignatureInfo, PublicKey } from "@solana/web3.js";
-export declare class SolanaEvents extends SolanaModule {
-    readonly LOG_FETCH_LIMIT = 500;
-    /**
-     * 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;
-    /**
-     * 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
-     */
-    findInSignatures<T>(topicKey: PublicKey, processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
-}
+import { SolanaModule } from "../SolanaModule";
+import { ConfirmedSignatureInfo, PublicKey } from "@solana/web3.js";
+export declare class SolanaEvents extends SolanaModule {
+    readonly LOG_FETCH_LIMIT = 500;
+    /**
+     * 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;
+    /**
+     * 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
+     */
+    findInSignatures<T>(topicKey: PublicKey, processor: (signatures: ConfirmedSignatureInfo[]) => Promise<T>, abortSignal?: AbortSignal, logFetchLimit?: number): Promise<T>;
+}

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

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaEvents = void 0;
-const SolanaModule_1 = require("../SolanaModule");
-class SolanaEvents extends SolanaModule_1.SolanaModule {
-    constructor() {
-        super(...arguments);
-        this.LOG_FETCH_LIMIT = 500;
-    }
-    /**
-     * 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
-     */
-    getSignatures(topicKey, logFetchLimit, lastProcessedSignature) {
-        if (lastProcessedSignature == null) {
-            return this.connection.getSignaturesForAddress(topicKey, {
-                limit: logFetchLimit,
-            }, "confirmed");
-        }
-        else {
-            return this.connection.getSignaturesForAddress(topicKey, {
-                before: lastProcessedSignature,
-                limit: logFetchLimit
-            }, "confirmed");
-        }
-    }
-    /**
-     * 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
-     */
-    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit) {
-        if (logFetchLimit == null || logFetchLimit > this.LOG_FETCH_LIMIT)
-            logFetchLimit = this.LOG_FETCH_LIMIT;
-        let signatures = null;
-        while (signatures == null || signatures.length > 0) {
-            signatures = await this.getSignatures(topicKey, logFetchLimit, signatures != null ? signatures[signatures.length - 1].signature : null);
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            const result = await processor(signatures);
-            if (result != null)
-                return result;
-            if (signatures.length < logFetchLimit)
-                break;
-        }
-        return null;
-    }
-}
-exports.SolanaEvents = SolanaEvents;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaEvents = void 0;
+const SolanaModule_1 = require("../SolanaModule");
+class SolanaEvents extends SolanaModule_1.SolanaModule {
+    constructor() {
+        super(...arguments);
+        this.LOG_FETCH_LIMIT = 500;
+    }
+    /**
+     * 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
+     */
+    getSignatures(topicKey, logFetchLimit, lastProcessedSignature) {
+        if (lastProcessedSignature == null) {
+            return this.connection.getSignaturesForAddress(topicKey, {
+                limit: logFetchLimit,
+            }, "confirmed");
+        }
+        else {
+            return this.connection.getSignaturesForAddress(topicKey, {
+                before: lastProcessedSignature,
+                limit: logFetchLimit
+            }, "confirmed");
+        }
+    }
+    /**
+     * 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
+     */
+    async findInSignatures(topicKey, processor, abortSignal, logFetchLimit) {
+        if (logFetchLimit == null || logFetchLimit > this.LOG_FETCH_LIMIT)
+            logFetchLimit = this.LOG_FETCH_LIMIT;
+        let signatures = null;
+        while (signatures == null || signatures.length > 0) {
+            signatures = await this.getSignatures(topicKey, logFetchLimit, signatures != null ? signatures[signatures.length - 1].signature : null);
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            const result = await processor(signatures);
+            if (result != null)
+                return result;
+            if (signatures.length < logFetchLimit)
+                break;
+        }
+        return null;
+    }
+}
+exports.SolanaEvents = SolanaEvents;

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

@@ -1,121 +1,121 @@
-/// <reference types="node" />
-import { Connection, PublicKey, SendOptions, Transaction } from "@solana/web3.js";
-export type FeeBribeData = {
-    address: string;
-    endpoint: string;
-    getBribeFee?: (original: bigint) => bigint;
-};
-export declare class SolanaFees {
-    private readonly connection;
-    private readonly maxFeeMicroLamports;
-    private readonly numSamples;
-    private readonly period;
-    private useHeliusApi;
-    private heliusApiSupported;
-    private readonly heliusFeeLevel;
-    private readonly bribeData?;
-    private readonly getStaticFee?;
-    private readonly logger;
-    private blockFeeCache;
-    constructor(connection: Connection, maxFeeMicroLamports?: number, numSamples?: number, period?: number, useHeliusApi?: "yes" | "no" | "auto", heliusFeeLevel?: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax", getStaticFee?: (feeRate: bigint) => bigint, bribeData?: FeeBribeData);
-    /**
-     * Returns solana block with transactionDetails="signatures"
-     *
-     * @param slot
-     * @private
-     */
-    private getBlockWithSignature;
-    /**
-     * Returns fee estimate from Helius API - only works with Helius RPC, return null for all other RPC providers
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    private getPriorityFeeEstimate;
-    /**
-     * Sends the transaction over Jito
-     *
-     * @param tx
-     * @param options
-     * @private
-     * @returns {Promise<string>} transaction signature
-     */
-    private sendJitoTx;
-    /**
-     * Checks whether the transaction should be sent over Jito, returns the fee paid to Jito in case the transaction
-     *  should be sent over Jito, returns null if the transaction shouldn't be sent over Jito
-     *
-     * @param parsedTx
-     * @private
-     */
-    private getJitoTxFee;
-    /**
-     * Gets the mean microLamports/CU fee rate for the block at a specific slot
-     *
-     * @param slot
-     * @private
-     */
-    private getBlockMeanFeeRate;
-    /**
-     * Manually gets global fee rate by sampling random blocks over the last period
-     *
-     * @private
-     * @returns {Promise<BN>} sampled mean microLamports/CU fee over the last period
-     */
-    private _getGlobalFeeRate;
-    /**
-     * Gets the combined microLamports/CU fee rate (from localized & global fee market)
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    private _getFeeRate;
-    /**
-     * Gets global fee rate, with caching
-     *
-     * @returns {Promise<BN>} global fee rate microLamports/CU
-     */
-    getGlobalFeeRate(): Promise<bigint>;
-    /**
-     * Gets the combined microLamports/CU fee rate (from localized & global fee market), cached & adjusted as for
-     *  when bribe and/or static fee should be included, format: <uLamports/CU>;<static fee lamport>[;<bribe address>]
-     *
-     * @param mutableAccounts
-     * @private
-     */
-    getFeeRate(mutableAccounts: PublicKey[]): Promise<string>;
-    /**
-     * Calculates the total priority fee paid for a given compute budget at a given fee rate
-     *
-     * @param computeUnits
-     * @param feeRate
-     * @param includeStaticFee whether the include the static/base part of the fee rate
-     */
-    getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee?: boolean): bigint;
-    /**
-     * Applies fee rate to a transaction at the beginning of the transaction (has to be called after
-     *  feePayer is set for the tx), specifically adds the setComputeUnitLimit & setComputeUnitPrice instruction
-     *
-     * @param tx
-     * @param computeBudget
-     * @param feeRate
-     */
-    applyFeeRateBegin(tx: Transaction, computeBudget: number, feeRate: string): boolean;
-    /**
-     * Applies fee rate to the end of the transaction (has to be called after feePayer is set for the tx),
-     *  specifically adds the bribe SystemProgram.transfer instruction
-     *
-     * @param tx
-     * @param computeBudget
-     * @param feeRate
-     */
-    applyFeeRateEnd(tx: Transaction, computeBudget: number, feeRate: string): boolean;
-    /**
-     * Checks if the transaction should be submitted over Jito and if yes submits it
-     *
-     * @param tx
-     * @param options
-     * @returns {Promise<string | null>} null if the transaction was not sent over Jito, tx signature when tx was sent over Jito
-     */
-    submitTx(tx: Buffer, options?: SendOptions): Promise<string | null>;
-}
+/// <reference types="node" />
+import { Connection, PublicKey, SendOptions, Transaction } from "@solana/web3.js";
+export type FeeBribeData = {
+    address: string;
+    endpoint: string;
+    getBribeFee?: (original: bigint) => bigint;
+};
+export declare class SolanaFees {
+    private readonly connection;
+    private readonly maxFeeMicroLamports;
+    private readonly numSamples;
+    private readonly period;
+    private useHeliusApi;
+    private heliusApiSupported;
+    private readonly heliusFeeLevel;
+    private readonly bribeData?;
+    private readonly getStaticFee?;
+    private readonly logger;
+    private blockFeeCache;
+    constructor(connection: Connection, maxFeeMicroLamports?: number, numSamples?: number, period?: number, useHeliusApi?: "yes" | "no" | "auto", heliusFeeLevel?: "min" | "low" | "medium" | "high" | "veryHigh" | "unsafeMax", getStaticFee?: (feeRate: bigint) => bigint, bribeData?: FeeBribeData);
+    /**
+     * Returns solana block with transactionDetails="signatures"
+     *
+     * @param slot
+     * @private
+     */
+    private getBlockWithSignature;
+    /**
+     * Returns fee estimate from Helius API - only works with Helius RPC, return null for all other RPC providers
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    private getPriorityFeeEstimate;
+    /**
+     * Sends the transaction over Jito
+     *
+     * @param tx
+     * @param options
+     * @private
+     * @returns {Promise<string>} transaction signature
+     */
+    private sendJitoTx;
+    /**
+     * Checks whether the transaction should be sent over Jito, returns the fee paid to Jito in case the transaction
+     *  should be sent over Jito, returns null if the transaction shouldn't be sent over Jito
+     *
+     * @param parsedTx
+     * @private
+     */
+    private getJitoTxFee;
+    /**
+     * Gets the mean microLamports/CU fee rate for the block at a specific slot
+     *
+     * @param slot
+     * @private
+     */
+    private getBlockMeanFeeRate;
+    /**
+     * Manually gets global fee rate by sampling random blocks over the last period
+     *
+     * @private
+     * @returns {Promise<BN>} sampled mean microLamports/CU fee over the last period
+     */
+    private _getGlobalFeeRate;
+    /**
+     * Gets the combined microLamports/CU fee rate (from localized & global fee market)
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    private _getFeeRate;
+    /**
+     * Gets global fee rate, with caching
+     *
+     * @returns {Promise<BN>} global fee rate microLamports/CU
+     */
+    getGlobalFeeRate(): Promise<bigint>;
+    /**
+     * Gets the combined microLamports/CU fee rate (from localized & global fee market), cached & adjusted as for
+     *  when bribe and/or static fee should be included, format: <uLamports/CU>;<static fee lamport>[;<bribe address>]
+     *
+     * @param mutableAccounts
+     * @private
+     */
+    getFeeRate(mutableAccounts: PublicKey[]): Promise<string>;
+    /**
+     * Calculates the total priority fee paid for a given compute budget at a given fee rate
+     *
+     * @param computeUnits
+     * @param feeRate
+     * @param includeStaticFee whether the include the static/base part of the fee rate
+     */
+    getPriorityFee(computeUnits: number, feeRate: string, includeStaticFee?: boolean): bigint;
+    /**
+     * Applies fee rate to a transaction at the beginning of the transaction (has to be called after
+     *  feePayer is set for the tx), specifically adds the setComputeUnitLimit & setComputeUnitPrice instruction
+     *
+     * @param tx
+     * @param computeBudget
+     * @param feeRate
+     */
+    applyFeeRateBegin(tx: Transaction, computeBudget: number, feeRate: string): boolean;
+    /**
+     * Applies fee rate to the end of the transaction (has to be called after feePayer is set for the tx),
+     *  specifically adds the bribe SystemProgram.transfer instruction
+     *
+     * @param tx
+     * @param computeBudget
+     * @param feeRate
+     */
+    applyFeeRateEnd(tx: Transaction, computeBudget: number, feeRate: string): boolean;
+    /**
+     * Checks if the transaction should be submitted over Jito and if yes submits it
+     *
+     * @param tx
+     * @param options
+     * @returns {Promise<string | null>} null if the transaction was not sent over Jito, tx signature when tx was sent over Jito
+     */
+    submitTx(tx: Buffer, options?: SendOptions): Promise<string | null>;
+}