@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/browser/tx/baseTxSender.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+import NodeCache from 'node-cache';
+export declare abstract class BaseTxSender implements TxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    additionalConnections: Connection[];
+    timeoutCount: number;
+    confirmationStrategy: ConfirmationStrategy;
+    additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+    txHandler: TxHandler;
+    trackTxLandRate?: boolean;
+    throwOnTimeoutError: boolean;
+    throwOnTransactionError: boolean;
+    lookbackWindowMinutes: number;
+    txSigCache?: NodeCache;
+    txLandRate: number;
+    lastPriorityFeeSuggestion: number;
+    landRateToFeeFunc: (landRate: number) => number;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError, throwOnTransactionError, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        additionalConnections?: any;
+        confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
+        throwOnTimeoutError?: boolean;
+        throwOnTransactionError?: boolean;
+    });
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: BlockhashWithExpiryBlockHeight): Promise<VersionedTransaction>;
+    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+    simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
+    confirmTransactionWebSocket(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    confirmTransactionPolling(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult> | undefined>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    promiseTimeout<T>(promises: Promise<T>[], timeoutMs: number): Promise<T | null>;
+    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, opts: ConfirmOptions): void;
+    addAdditionalConnection(newConnection: Connection): void;
+    getTimeoutCount(): number;
+    checkConfirmationResultForError(txSig: string, result: SignatureResult): Promise<void>;
+    getTxLandRate(): number;
+    private defaultLandRateToFeeFunc;
+    getSuggestedPriorityFeeMultiplier(): number;
+}

package/lib/browser/tx/baseTxSender.js

@@ -0,0 +1,294 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTxSender = void 0;
+const types_1 = require("./types");
+const assert_1 = __importDefault(require("assert"));
+const bs58_1 = __importDefault(require("bs58"));
+const txHandler_1 = require("./txHandler");
+const node_cache_1 = __importDefault(require("node-cache"));
+const config_1 = require("../config");
+const txConstants_1 = require("../constants/txConstants");
+const reportTransactionError_1 = require("./reportTransactionError");
+const BASELINE_TX_LAND_RATE = 0.9;
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES = 10;
+class BaseTxSender {
+    constructor({ connection, wallet, opts = config_1.DEFAULT_CONFIRMATION_OPTS, timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes = DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES, landRateToFeeFunc, throwOnTimeoutError = true, throwOnTransactionError = true, }) {
+        this.timeoutCount = 0;
+        this.txLandRate = 0;
+        this.lastPriorityFeeSuggestion = 1;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.additionalConnections = additionalConnections;
+        this.confirmationStrategy = confirmationStrategy;
+        this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
+        this.txHandler =
+            txHandler !== null && txHandler !== void 0 ? txHandler : new txHandler_1.TxHandler({
+                connection: this.connection,
+                wallet: this.wallet,
+                confirmationOptions: this.opts,
+            });
+        this.trackTxLandRate = trackTxLandRate;
+        this.lookbackWindowMinutes = txLandRateLookbackWindowMinutes * 60;
+        if (this.trackTxLandRate) {
+            this.txSigCache = new node_cache_1.default({
+                stdTTL: this.lookbackWindowMinutes,
+                checkperiod: 120,
+            });
+        }
+        this.landRateToFeeFunc =
+            landRateToFeeFunc !== null && landRateToFeeFunc !== void 0 ? landRateToFeeFunc : this.defaultLandRateToFeeFunc.bind(this);
+        this.throwOnTimeoutError = throwOnTimeoutError;
+        this.throwOnTransactionError = throwOnTransactionError;
+    }
+    async send(tx, additionalSigners, opts, preSigned) {
+        if (additionalSigners === undefined) {
+            additionalSigners = [];
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        const signedTx = await this.prepareTx(tx, additionalSigners, opts, preSigned);
+        return this.sendRawTransaction(signedTx.serialize(), opts);
+    }
+    async prepareTx(tx, additionalSigners, opts, preSigned) {
+        return this.txHandler.prepareTx(tx, additionalSigners, undefined, opts, preSigned);
+    }
+    async getVersionedTransaction(ixs, lookupTableAccounts, _additionalSigners, opts, blockhash) {
+        return this.txHandler.generateVersionedTransaction(blockhash, ixs, lookupTableAccounts, this.wallet);
+    }
+    async sendVersionedTransaction(tx, additionalSigners, opts, preSigned) {
+        let signedTx;
+        if (preSigned) {
+            signedTx = tx;
+            // @ts-ignore
+        }
+        else if (this.wallet.payer) {
+            // @ts-ignore
+            tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.wallet.payer));
+            signedTx = tx;
+        }
+        else {
+            signedTx = await this.txHandler.signVersionedTx(tx, additionalSigners, undefined, this.wallet);
+        }
+        if (opts === undefined) {
+            opts = this.opts;
+        }
+        return this.sendRawTransaction(signedTx.serialize(), opts);
+    }
+    async sendRawTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    rawTransaction, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    opts) {
+        throw new Error('Must be implemented by subclass');
+    }
+    /* Simulate the tx and return a boolean for success value */
+    async simulateTransaction(tx) {
+        try {
+            const result = await this.connection.simulateTransaction(tx);
+            if (result.value.err != null) {
+                console.error('Error in transaction simulation: ', result.value.err);
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            console.error('Error calling simulateTransaction: ', e);
+            return false;
+        }
+    }
+    async confirmTransactionWebSocket(signature, commitment) {
+        var _a, _b;
+        let decodedSignature;
+        try {
+            decodedSignature = bs58_1.default.decode(signature);
+        }
+        catch (err) {
+            throw new Error('signature must be base58 encoded: ' + signature);
+        }
+        (0, assert_1.default)(decodedSignature.length === 64, 'signature has invalid length');
+        const start = Date.now();
+        const subscriptionCommitment = commitment || this.opts.commitment;
+        const subscriptionIds = new Array();
+        const connections = [this.connection, ...this.additionalConnections];
+        let response = null;
+        const promises = connections.map((connection, i) => {
+            let subscriptionId;
+            const confirmPromise = new Promise((resolve, reject) => {
+                try {
+                    subscriptionId = connection.onSignature(signature, (result, context) => {
+                        subscriptionIds[i] = undefined;
+                        response = {
+                            context,
+                            value: result,
+                        };
+                        resolve(null);
+                    }, subscriptionCommitment);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+            subscriptionIds.push(subscriptionId);
+            return confirmPromise;
+        });
+        try {
+            await this.promiseTimeout(promises, this.timeout);
+        }
+        finally {
+            for (const [i, subscriptionId] of subscriptionIds.entries()) {
+                if (subscriptionId) {
+                    connections[i].removeSignatureListener(subscriptionId);
+                }
+            }
+        }
+        if (response === null) {
+            if (this.confirmationStrategy === types_1.ConfirmationStrategy.Combo) {
+                try {
+                    const rpcResponse = await this.connection.getSignatureStatuses([
+                        signature,
+                    ]);
+                    if ((_b = (_a = rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.confirmationStatus) {
+                        response = {
+                            context: rpcResponse.context,
+                            value: { err: rpcResponse.value[0].err },
+                        };
+                        return response;
+                    }
+                }
+                catch (error) {
+                    // Ignore error to pass through to timeout error
+                }
+            }
+            this.timeoutCount += 1;
+            const duration = (Date.now() - start) / 1000;
+            if (this.throwOnTimeoutError) {
+                throw new types_1.TxSendError(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`, txConstants_1.NOT_CONFIRMED_ERROR_CODE);
+            }
+        }
+        return response;
+    }
+    async confirmTransactionPolling(signature, commitment = 'finalized') {
+        var _a;
+        let totalTime = 0;
+        let backoffTime = 400; // approx block time
+        const start = Date.now();
+        while (totalTime < this.timeout) {
+            await new Promise((resolve) => setTimeout(resolve, backoffTime));
+            const rpcResponse = await this.connection.getSignatureStatuses([
+                signature,
+            ]);
+            const signatureResult = rpcResponse && ((_a = rpcResponse.value) === null || _a === void 0 ? void 0 : _a[0]);
+            if (rpcResponse &&
+                signatureResult &&
+                signatureResult.confirmationStatus === commitment) {
+                return { context: rpcResponse.context, value: { err: null } };
+            }
+            totalTime += backoffTime;
+            backoffTime = Math.min(backoffTime * 2, 5000);
+        }
+        // Transaction not confirmed within 30 seconds
+        this.timeoutCount += 1;
+        const duration = (Date.now() - start) / 1000;
+        if (this.throwOnTimeoutError) {
+            throw new types_1.TxSendError(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`, txConstants_1.NOT_CONFIRMED_ERROR_CODE);
+        }
+    }
+    async confirmTransaction(signature, commitment) {
+        if (this.confirmationStrategy === types_1.ConfirmationStrategy.WebSocket ||
+            this.confirmationStrategy === types_1.ConfirmationStrategy.Combo) {
+            return await this.confirmTransactionWebSocket(signature, commitment);
+        }
+        else if (this.confirmationStrategy === types_1.ConfirmationStrategy.Polling) {
+            return await this.confirmTransactionPolling(signature, commitment);
+        }
+    }
+    getTimestamp() {
+        return new Date().getTime();
+    }
+    promiseTimeout(promises, timeoutMs) {
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve) => {
+            timeoutId = setTimeout(() => resolve(null), timeoutMs);
+        });
+        return Promise.race([...promises, timeoutPromise]).then((result) => {
+            clearTimeout(timeoutId);
+            return result;
+        });
+    }
+    sendToAdditionalConnections(rawTx, opts) {
+        var _a;
+        this.additionalConnections.map((connection) => {
+            connection.sendRawTransaction(rawTx, opts).catch((e) => {
+                console.error(
+                // @ts-ignore
+                `error sending tx to additional connection ${connection._rpcEndpoint}`);
+                console.error(e);
+            });
+        });
+        (_a = this.additionalTxSenderCallbacks) === null || _a === void 0 ? void 0 : _a.map((callback) => {
+            callback(bs58_1.default.encode(rawTx));
+        });
+    }
+    addAdditionalConnection(newConnection) {
+        const alreadyUsingConnection = this.additionalConnections.filter((connection) => {
+            // @ts-ignore
+            return connection._rpcEndpoint === newConnection.rpcEndpoint;
+        }).length > 0;
+        if (!alreadyUsingConnection) {
+            this.additionalConnections.push(newConnection);
+        }
+    }
+    getTimeoutCount() {
+        return this.timeoutCount;
+    }
+    async checkConfirmationResultForError(txSig, result) {
+        var _a;
+        if (result === null || result === void 0 ? void 0 : result.err) {
+            await (0, reportTransactionError_1.throwTransactionError)(txSig, this.connection, (_a = this.opts) === null || _a === void 0 ? void 0 : _a.commitment);
+        }
+        return;
+    }
+    getTxLandRate() {
+        if (!this.trackTxLandRate) {
+            console.warn('trackTxLandRate is false, returning default land rate of 0');
+            return this.txLandRate;
+        }
+        const keys = this.txSigCache.keys();
+        const denominator = keys.length;
+        if (denominator === 0) {
+            return this.txLandRate;
+        }
+        let numerator = 0;
+        for (const key of keys) {
+            const value = this.txSigCache.get(key);
+            if (value) {
+                numerator += 1;
+            }
+        }
+        this.txLandRate = numerator / denominator;
+        return this.txLandRate;
+    }
+    defaultLandRateToFeeFunc(txLandRate) {
+        if (txLandRate >= BASELINE_TX_LAND_RATE ||
+            this.txSigCache.keys().length < 3) {
+            return 1;
+        }
+        const multiplier = 10 * Math.log10(1 + (BASELINE_TX_LAND_RATE - txLandRate) * 5);
+        return Math.min(multiplier, 10);
+    }
+    getSuggestedPriorityFeeMultiplier() {
+        if (!this.trackTxLandRate) {
+            console.warn('trackTxLandRate is false, returning default multiplier of 1');
+            return 1;
+        }
+        return this.landRateToFeeFunc(this.getTxLandRate());
+    }
+}
+exports.BaseTxSender = BaseTxSender;

package/lib/browser/tx/blockhashFetcher/baseBlockhashFetcher.d.ts

@@ -0,0 +1,8 @@
+import { BlockhashWithExpiryBlockHeight, Commitment, Connection } from '@solana/web3.js';
+import { BlockhashFetcher } from './types';
+export declare class BaseBlockhashFetcher implements BlockhashFetcher {
+    private connection;
+    private blockhashCommitment;
+    constructor(connection: Connection, blockhashCommitment: Commitment);
+    getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
+}

package/lib/browser/tx/blockhashFetcher/baseBlockhashFetcher.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseBlockhashFetcher = void 0;
+class BaseBlockhashFetcher {
+    constructor(connection, blockhashCommitment) {
+        this.connection = connection;
+        this.blockhashCommitment = blockhashCommitment;
+    }
+    async getLatestBlockhash() {
+        return this.connection.getLatestBlockhash(this.blockhashCommitment);
+    }
+}
+exports.BaseBlockhashFetcher = BaseBlockhashFetcher;

package/lib/browser/tx/blockhashFetcher/cachedBlockhashFetcher.d.ts

@@ -0,0 +1,28 @@
+import { BlockhashWithExpiryBlockHeight, Commitment, Connection } from '@solana/web3.js';
+import { BlockhashFetcher } from './types';
+/**
+ * Fetches the latest blockhash and caches it for a configurable amount of time.
+ *
+ * - Prevents RPC spam by reusing cached values
+ * - Retries on failure with exponential backoff
+ * - Prevents concurrent requests for the same blockhash
+ */
+export declare class CachedBlockhashFetcher implements BlockhashFetcher {
+    private connection;
+    private blockhashCommitment;
+    private retryCount;
+    private retrySleepTimeMs;
+    private staleCacheTimeMs;
+    private recentBlockhashCache;
+    private blockhashFetchingPromise;
+    constructor(connection: Connection, blockhashCommitment: Commitment, retryCount: number, retrySleepTimeMs: number, staleCacheTimeMs: number);
+    private fetchBlockhashWithRetry;
+    private sleep;
+    private updateBlockhashCache;
+    getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
+    private isCacheStale;
+    /**
+     * Refresh the blockhash cache, await a pending refresh if it exists
+     */
+    private refreshBlockhash;
+}

package/lib/browser/tx/blockhashFetcher/cachedBlockhashFetcher.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedBlockhashFetcher = void 0;
+/**
+ * Fetches the latest blockhash and caches it for a configurable amount of time.
+ *
+ * - Prevents RPC spam by reusing cached values
+ * - Retries on failure with exponential backoff
+ * - Prevents concurrent requests for the same blockhash
+ */
+class CachedBlockhashFetcher {
+    constructor(connection, blockhashCommitment, retryCount, retrySleepTimeMs, staleCacheTimeMs) {
+        this.connection = connection;
+        this.blockhashCommitment = blockhashCommitment;
+        this.retryCount = retryCount;
+        this.retrySleepTimeMs = retrySleepTimeMs;
+        this.staleCacheTimeMs = staleCacheTimeMs;
+        this.recentBlockhashCache = { value: undefined, lastUpdated: 0 };
+        this.blockhashFetchingPromise = null;
+    }
+    async fetchBlockhashWithRetry() {
+        for (let i = 0; i < this.retryCount; i++) {
+            try {
+                return await this.connection.getLatestBlockhash(this.blockhashCommitment);
+            }
+            catch (err) {
+                if (i === this.retryCount - 1) {
+                    throw new Error('Failed to fetch blockhash after maximum retries');
+                }
+                await this.sleep(this.retrySleepTimeMs * 2 ** i);
+            }
+        }
+        throw new Error('Failed to fetch blockhash after maximum retries');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async updateBlockhashCache() {
+        const result = await this.fetchBlockhashWithRetry();
+        this.recentBlockhashCache = {
+            value: result,
+            lastUpdated: Date.now(),
+        };
+    }
+    async getLatestBlockhash() {
+        if (this.isCacheStale()) {
+            await this.refreshBlockhash();
+        }
+        return this.recentBlockhashCache.value;
+    }
+    isCacheStale() {
+        const lastUpdateTime = this.recentBlockhashCache.lastUpdated;
+        return (!lastUpdateTime || Date.now() > lastUpdateTime + this.staleCacheTimeMs);
+    }
+    /**
+     * Refresh the blockhash cache, await a pending refresh if it exists
+     */
+    async refreshBlockhash() {
+        if (!this.blockhashFetchingPromise) {
+            this.blockhashFetchingPromise = this.updateBlockhashCache();
+            try {
+                await this.blockhashFetchingPromise;
+            }
+            finally {
+                this.blockhashFetchingPromise = null;
+            }
+        }
+        else {
+            await this.blockhashFetchingPromise;
+        }
+    }
+}
+exports.CachedBlockhashFetcher = CachedBlockhashFetcher;

package/lib/browser/tx/blockhashFetcher/types.d.ts

@@ -0,0 +1,4 @@
+import { BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+export interface BlockhashFetcher {
+    getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
+}

package/lib/browser/tx/blockhashFetcher/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/browser/tx/fastSingleTxSender.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
+import { ConfirmOptions, Connection, Commitment, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+import { BaseTxSender } from './baseTxSender';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+export declare class FastSingleTxSender extends BaseTxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    blockhashRefreshInterval: number;
+    additionalConnections: Connection[];
+    timoutCount: number;
+    recentBlockhash: BlockhashWithExpiryBlockHeight;
+    skipConfirmation: boolean;
+    confirmInBackground: boolean;
+    blockhashCommitment: Commitment;
+    blockhashIntervalId: NodeJS.Timer;
+    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, confirmInBackground, blockhashCommitment, confirmationStrategy, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        blockhashRefreshInterval?: number;
+        additionalConnections?: any;
+        skipConfirmation?: boolean;
+        confirmInBackground?: boolean;
+        blockhashCommitment?: Commitment;
+        confirmationStrategy?: ConfirmationStrategy;
+        trackTxLandRate?: boolean;
+        txHandler?: TxHandler;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
+        throwOnTimeoutError?: boolean;
+    });
+    startBlockhashRefreshLoop(): void;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+}

package/lib/browser/tx/fastSingleTxSender.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastSingleTxSender = void 0;
+const types_1 = require("./types");
+const baseTxSender_1 = require("./baseTxSender");
+const config_1 = require("../config");
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_BLOCKHASH_REFRESH = 10000;
+class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
+    constructor({ connection, wallet, opts = { ...config_1.DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, confirmInBackground = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError = true, }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            timeout,
+            additionalConnections,
+            confirmationStrategy,
+            txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
+            throwOnTimeoutError,
+        });
+        this.timoutCount = 0;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.blockhashRefreshInterval = blockhashRefreshInterval;
+        this.additionalConnections = additionalConnections;
+        this.skipConfirmation = skipConfirmation;
+        this.confirmInBackground = confirmInBackground;
+        this.blockhashCommitment = blockhashCommitment;
+        this.startBlockhashRefreshLoop();
+    }
+    startBlockhashRefreshLoop() {
+        if (this.blockhashRefreshInterval > 0) {
+            this.blockhashIntervalId = setInterval(async () => {
+                try {
+                    this.recentBlockhash = await this.connection.getLatestBlockhash(this.blockhashCommitment);
+                }
+                catch (e) {
+                    console.error('Error in startBlockhashRefreshLoop: ', e);
+                }
+            }, this.blockhashRefreshInterval);
+        }
+    }
+    async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b, _c;
+        let txid;
+        try {
+            txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+            (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, false);
+            this.sendToAdditionalConnections(rawTransaction, opts);
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+        let slot;
+        if (!this.skipConfirmation) {
+            try {
+                if (this.confirmInBackground) {
+                    this.confirmTransaction(txid, opts.commitment).then(async (result) => {
+                        var _a;
+                        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, true);
+                        await this.checkConfirmationResultForError(txid, result === null || result === void 0 ? void 0 : result.value);
+                        slot = result.context.slot;
+                    });
+                }
+                else {
+                    const result = await this.confirmTransaction(txid, opts.commitment);
+                    (_b = this.txSigCache) === null || _b === void 0 ? void 0 : _b.set(txid, true);
+                    await this.checkConfirmationResultForError(txid, result === null || result === void 0 ? void 0 : result.value);
+                    slot = (_c = result === null || result === void 0 ? void 0 : result.context) === null || _c === void 0 ? void 0 : _c.slot;
+                }
+            }
+            catch (e) {
+                console.error(e);
+                throw e;
+            }
+        }
+        return { txSig: txid, slot };
+    }
+}
+exports.FastSingleTxSender = FastSingleTxSender;

package/lib/browser/tx/forwardOnlyTxSender.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConfirmOptions, Connection } from '@solana/web3.js';
+import { BaseTxSender } from './baseTxSender';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+type ResolveReference = {
+    resolve?: () => void;
+};
+export declare class ForwardOnlyTxSender extends BaseTxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    retrySleep: number;
+    additionalConnections: Connection[];
+    timoutCount: number;
+    constructor({ connection, wallet, opts, timeout, retrySleep, confirmationStrategy, additionalTxSenderCallbacks, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        retrySleep?: number;
+        confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
+        throwOnTimeoutError?: boolean;
+    });
+    sleep(reference: ResolveReference): Promise<void>;
+    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, _opts: ConfirmOptions): void;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+}
+export {};