@velocity-exchange/sdk 0.0.1

package/lib/browser/tx/forwardOnlyTxSender.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForwardOnlyTxSender = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bs58_1 = __importDefault(require("bs58"));
+const baseTxSender_1 = require("./baseTxSender");
+const types_1 = require("./types");
+const config_1 = require("../config");
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_RETRY = 5000;
+class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
+    constructor({ connection, wallet, opts = { ...config_1.DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError = true, }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            timeout,
+            additionalConnections: [],
+            confirmationStrategy,
+            additionalTxSenderCallbacks,
+            txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
+            throwOnTimeoutError,
+        });
+        this.timoutCount = 0;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.retrySleep = retrySleep;
+        this.additionalConnections = [];
+    }
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
+        });
+    }
+    sendToAdditionalConnections(rawTx, _opts) {
+        var _a;
+        (_a = this.additionalTxSenderCallbacks) === null || _a === void 0 ? void 0 : _a.map((callback) => {
+            callback(bs58_1.default.encode(rawTx));
+        });
+    }
+    async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b, _c;
+        const deserializedTx = web3_js_1.VersionedTransaction.deserialize(rawTransaction);
+        const txSig = deserializedTx.signatures[0];
+        const encodedTxSig = bs58_1.default.encode(txSig);
+        const startTime = this.getTimestamp();
+        this.sendToAdditionalConnections(rawTransaction, opts);
+        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(encodedTxSig, false);
+        let done = false;
+        const resolveReference = {
+            resolve: undefined,
+        };
+        const stopWaiting = () => {
+            done = true;
+            if (resolveReference.resolve) {
+                resolveReference.resolve();
+            }
+        };
+        (async () => {
+            while (!done && this.getTimestamp() - startTime < this.timeout) {
+                await this.sleep(resolveReference);
+                if (!done) {
+                    this.sendToAdditionalConnections(rawTransaction, opts);
+                }
+            }
+        })();
+        let slot;
+        try {
+            const result = await this.confirmTransaction(encodedTxSig, opts.commitment);
+            slot = (_b = result === null || result === void 0 ? void 0 : result.context) === null || _b === void 0 ? void 0 : _b.slot;
+            (_c = this.txSigCache) === null || _c === void 0 ? void 0 : _c.set(encodedTxSig, true);
+            // eslint-disable-next-line no-useless-catch
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            stopWaiting();
+        }
+        return { txSig: encodedTxSig, slot };
+    }
+}
+exports.ForwardOnlyTxSender = ForwardOnlyTxSender;

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

@@ -0,0 +1,44 @@
+import { TransactionInstruction } from '@solana/web3.js';
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export declare class PriorityFeeCalculator {
+    lastTxTimeoutCount: number;
+    priorityFeeTriggered: boolean;
+    lastTxTimeoutCountTriggered: number;
+    priorityFeeLatchDurationMs: number;
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs: number, priorityFeeLatchDurationMs?: number);
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs: number, txTimeoutCount: number): boolean;
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit: number): Array<TransactionInstruction>;
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit: number, additionalFeeMicroLamports: number): number;
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit: number, usePriorityFee: boolean, additionalFeeMicroLamports: number): Array<TransactionInstruction>;
+}

package/lib/browser/tx/priorityFeeCalculator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeCalculator = void 0;
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+class PriorityFeeCalculator {
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs, priorityFeeLatchDurationMs = 10 * 1000) {
+        this.lastTxTimeoutCount = 0;
+        this.priorityFeeTriggered = false;
+        this.lastTxTimeoutCountTriggered = currentTimeMs;
+        this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
+    }
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs, txTimeoutCount) {
+        let triggerPriorityFee = false;
+        if (txTimeoutCount > this.lastTxTimeoutCount) {
+            this.lastTxTimeoutCount = txTimeoutCount;
+            this.lastTxTimeoutCountTriggered = currentTimeMs;
+            triggerPriorityFee = true;
+        }
+        else {
+            if (!this.priorityFeeTriggered) {
+                triggerPriorityFee = false;
+            }
+            else if (currentTimeMs - this.lastTxTimeoutCountTriggered <
+                this.priorityFeeLatchDurationMs) {
+                triggerPriorityFee = true;
+            }
+        }
+        this.priorityFeeTriggered = triggerPriorityFee;
+        return triggerPriorityFee;
+    }
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit) {
+        const ixs = [
+            web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+                units: computeUnitLimit,
+            }),
+        ];
+        return ixs;
+    }
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports) {
+        return additionalFeeMicroLamports / computeUnitLimit;
+    }
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit, usePriorityFee, additionalFeeMicroLamports) {
+        const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
+        if (usePriorityFee) {
+            const computeUnitPrice = this.calculateComputeUnitPrice(computeUnitLimit, additionalFeeMicroLamports);
+            ixs.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: computeUnitPrice,
+            }));
+        }
+        return ixs;
+    }
+}
+exports.PriorityFeeCalculator = PriorityFeeCalculator;

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

@@ -0,0 +1,20 @@
+import { Commitment, Connection, SendTransactionError, VersionedTransactionResponse } from '@solana/web3.js';
+/**
+ * THROWS if there is an error
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+export declare const throwTransactionError: (txSig: string, connection: Connection, commitment?: Commitment) => Promise<void>;
+/**
+ * RETURNS an error if there is one
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+export declare const getTransactionErrorFromTxSig: (txSig: string, connection: Connection, commitment?: Commitment) => Promise<SendTransactionError>;
+export declare const getTransactionError: (transactionResult: VersionedTransactionResponse) => SendTransactionError;

package/lib/browser/tx/reportTransactionError.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransactionError = exports.getTransactionErrorFromTxSig = exports.throwTransactionError = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const config_1 = require("../config");
+/**
+ * The new getTransaction method expects a Finality type instead of a Commitment type. The only options for Finality are 'confirmed' and 'finalized'.
+ * @param commitment
+ * @returns
+ */
+const commitmentToFinality = (commitment) => {
+    switch (commitment) {
+        case 'confirmed':
+            return 'confirmed';
+        case 'finalized':
+            return 'finalized';
+        default:
+            throw new Error(`Invalid commitment when reporting transaction error. The commitment must be 'confirmed' or 'finalized' but was given '${commitment}'. If you're using this commitment for a specific reason, you may need to roll your own logic here.`);
+    }
+};
+const getTransactionResult = async (txSig, connection, commitment) => {
+    const finality = commitmentToFinality(commitment || connection.commitment || config_1.DEFAULT_CONFIRMATION_OPTS.commitment);
+    return await connection.getTransaction(txSig, {
+        maxSupportedTransactionVersion: 0,
+        commitment: finality,
+    });
+};
+const getTransactionResultWithRetry = async (txSig, connection, commitment) => {
+    const start = Date.now();
+    const retryTimeout = 3000; // Timeout after 3 seconds
+    const retryInterval = 800; // Retry with 800ms interval
+    const retryCount = 3; // Retry 3 times
+    let currentCount = 0;
+    let transactionResult = await getTransactionResult(txSig, connection, commitment);
+    // Retry 3 times or until timeout as long as we don't have a result yet
+    while (!transactionResult &&
+        Date.now() - start < retryTimeout &&
+        currentCount < retryCount) {
+        // Sleep for 1 second :: Do this first so that we don't run the first loop immediately after the initial fetch above
+        await new Promise((resolve) => setTimeout(resolve, retryInterval));
+        transactionResult = await getTransactionResult(txSig, connection, commitment);
+        currentCount++;
+    }
+    return transactionResult;
+};
+/**
+ * THROWS if there is an error
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+const throwTransactionError = async (txSig, connection, commitment) => {
+    const err = await (0, exports.getTransactionErrorFromTxSig)(txSig, connection, commitment);
+    if (err) {
+        throw err;
+    }
+    return;
+};
+exports.throwTransactionError = throwTransactionError;
+/**
+ * RETURNS an error if there is one
+ *
+ * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
+ * @param txSig
+ * @param connection
+ * @returns
+ */
+const getTransactionErrorFromTxSig = async (txSig, connection, commitment) => {
+    var _a;
+    const transactionResult = await getTransactionResultWithRetry(txSig, connection, commitment);
+    if (!transactionResult) {
+        // Throw a generic error because we couldn't get the transaction result for the given txSig
+        return new web3_js_1.SendTransactionError({
+            action: 'send',
+            signature: txSig,
+            transactionMessage: `Transaction Failed`,
+        });
+    }
+    if (!((_a = transactionResult === null || transactionResult === void 0 ? void 0 : transactionResult.meta) === null || _a === void 0 ? void 0 : _a.err)) {
+        // Assume that the transaction was successful and we are here erroneously because we have a result with no error
+        return;
+    }
+    return (0, exports.getTransactionError)(transactionResult);
+};
+exports.getTransactionErrorFromTxSig = getTransactionErrorFromTxSig;
+const getTransactionError = (transactionResult) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (!((_a = transactionResult === null || transactionResult === void 0 ? void 0 : transactionResult.meta) === null || _a === void 0 ? void 0 : _a.err)) {
+        return;
+    }
+    const logs = (_c = (_b = transactionResult === null || transactionResult === void 0 ? void 0 : transactionResult.meta) === null || _b === void 0 ? void 0 : _b.logMessages) !== null && _c !== void 0 ? _c : ['No logs'];
+    const lastLog = logs[logs.length - 1];
+    const friendlyMessage = (_d = lastLog === null || lastLog === void 0 ? void 0 : lastLog.match(/(failed:) (.+)/)) === null || _d === void 0 ? void 0 : _d[2];
+    return new web3_js_1.SendTransactionError({
+        action: 'send',
+        signature: (_f = (_e = transactionResult === null || transactionResult === void 0 ? void 0 : transactionResult.transaction) === null || _e === void 0 ? void 0 : _e.signatures) === null || _f === void 0 ? void 0 : _f[0],
+        transactionMessage: `Transaction Failed${friendlyMessage ? `: ${friendlyMessage}` : ''}`,
+        logs,
+    });
+};
+exports.getTransactionError = getTransactionError;

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

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

package/lib/browser/tx/retryTxSender.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryTxSender = void 0;
+const types_1 = require("./types");
+const baseTxSender_1 = require("./baseTxSender");
+const config_1 = require("../config");
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_RETRY = 2000;
+class RetryTxSender extends baseTxSender_1.BaseTxSender {
+    constructor({ connection, wallet, opts = { ...config_1.DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError = true, }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            timeout,
+            additionalConnections,
+            confirmationStrategy,
+            additionalTxSenderCallbacks,
+            txHandler,
+            trackTxLandRate,
+            txLandRateLookbackWindowMinutes,
+            landRateToFeeFunc,
+            throwOnTimeoutError,
+        });
+        this.timoutCount = 0;
+        this.connection = connection;
+        this.wallet = wallet;
+        this.opts = opts;
+        this.timeout = timeout;
+        this.retrySleep = retrySleep;
+        this.additionalConnections = additionalConnections;
+    }
+    async sleep(reference) {
+        return new Promise((resolve) => {
+            reference.resolve = resolve;
+            setTimeout(resolve, this.retrySleep);
+        });
+    }
+    async sendRawTransaction(rawTransaction, opts) {
+        var _a, _b, _c;
+        const startTime = this.getTimestamp();
+        const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+        (_a = this.txSigCache) === null || _a === void 0 ? void 0 : _a.set(txid, false);
+        this.sendToAdditionalConnections(rawTransaction, opts);
+        let done = false;
+        const resolveReference = {
+            resolve: undefined,
+        };
+        const stopWaiting = () => {
+            done = true;
+            if (resolveReference.resolve) {
+                resolveReference.resolve();
+            }
+        };
+        (async () => {
+            while (!done && this.getTimestamp() - startTime < this.timeout) {
+                await this.sleep(resolveReference);
+                if (!done) {
+                    this.connection
+                        .sendRawTransaction(rawTransaction, opts)
+                        .catch((e) => {
+                        console.error(e);
+                        stopWaiting();
+                    });
+                    this.sendToAdditionalConnections(rawTransaction, opts);
+                }
+            }
+        })();
+        let slot;
+        try {
+            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;
+            // eslint-disable-next-line no-useless-catch
+        }
+        catch (e) {
+            throw e;
+        }
+        finally {
+            stopWaiting();
+        }
+        return { txSig: txid, slot };
+    }
+}
+exports.RetryTxSender = RetryTxSender;

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

@@ -0,0 +1,173 @@
+/**
+ * Transaction building and sending infrastructure.
+ *
+ * `txHandler.ts`     — base class for building versioned/legacy transactions with ALT support.
+ * `retryTxSender.ts` — retry loop with confirmation polling (default for most clients).
+ * `fastSingleTxSender.ts` — fire-and-forget path for latency-sensitive keeper bots.
+ * `priorityFeeCalculator.ts` — computes dynamic priority fees from recent fee estimates.
+ * `txParamProcessor.ts` — resolves CU limits and priority fees before send.
+ *
+ * Transaction sender is injected via VelocityClientConfig; swap implementations to tune
+ * confirmation strategy without changing instruction-building code.
+ */
+import { AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, Commitment, ConfirmOptions, Connection, Signer, SimulatedTransactionResponse, Transaction, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { VelocityClientMetricsEvents, IWallet, MappedRecord, SignedTxData, TxParams } from '../types';
+export declare const COMPUTE_UNITS_DEFAULT = 200000;
+export type TxBuildingProps = {
+    instructions: TransactionInstruction | TransactionInstruction[];
+    txVersion: TransactionVersion;
+    connection: Connection;
+    preFlightCommitment: Commitment;
+    fetchAllMarketLookupTableAccounts: () => Promise<AddressLookupTableAccount[]>;
+    lookupTables?: AddressLookupTableAccount[];
+    forceVersionedTransaction?: boolean;
+    txParams?: TxParams;
+    recentBlockhash?: BlockhashWithExpiryBlockHeight;
+    wallet?: IWallet;
+    optionalIxs?: TransactionInstruction[];
+    simulatedTx?: SimulatedTransactionResponse;
+};
+export type TxHandlerConfig = {
+    blockhashCachingEnabled?: boolean;
+    blockhashCachingConfig?: {
+        retryCount: number;
+        retrySleepTimeMs: number;
+        staleCacheTimeMs: number;
+    };
+};
+/**
+ * This class is responsible for creating and signing transactions.
+ */
+export declare class TxHandler {
+    private blockHashToLastValidBlockHeightLookup;
+    private returnBlockHeightsWithSignedTxCallbackData;
+    private connection;
+    private wallet;
+    private confirmationOptions;
+    private preSignedCb?;
+    private onSignedCb?;
+    private blockhashCommitment;
+    private blockHashFetcher;
+    constructor(props: {
+        connection: Connection;
+        wallet: IWallet;
+        confirmationOptions: ConfirmOptions;
+        opts?: {
+            returnBlockHeightsWithSignedTxCallbackData?: boolean;
+            onSignedCb?: (txSigs: VelocityClientMetricsEvents['txSigned']) => void;
+            preSignedCb?: () => void;
+        };
+        config?: TxHandlerConfig;
+    });
+    getWallet(): IWallet;
+    private addHashAndExpiryToLookup;
+    private getProps;
+    updateWallet(wallet: IWallet): void;
+    /**
+     * Created this to prevent non-finalized blockhashes being used when building transactions. We want to always use finalized because otherwise it's easy to get the BlockHashNotFound error (RPC uses finalized to validate a transaction). Using an older blockhash when building transactions should never really be a problem right now.
+     *
+     * https://www.helius.dev/blog/how-to-deal-with-blockhash-errors-on-solana#why-do-blockhash-errors-occur
+     *
+     * @returns
+     */
+    getLatestBlockhashForTransaction(): Promise<Readonly<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>>;
+    /**
+     * Applies recent blockhash and signs a given transaction
+     * @param tx
+     * @param additionalSigners
+     * @param wallet
+     * @param confirmationOpts
+     * @param preSigned
+     * @param recentBlockhash
+     * @returns
+     */
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, wallet?: IWallet, confirmationOpts?: ConfirmOptions, preSigned?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<Transaction>;
+    private isVersionedTransaction;
+    private isLegacyTransaction;
+    private getTxSigFromSignedTx;
+    private getBlockhashFromSignedTx;
+    private signTx;
+    signVersionedTx(tx: VersionedTransaction, additionalSigners: Array<Signer>, recentBlockhash?: BlockhashWithExpiryBlockHeight, wallet?: IWallet): Promise<VersionedTransaction>;
+    private handleSignedTxData;
+    /**
+     * Gets transaction params with extra processing applied, like using the simulated compute units or using a dynamically calculated compute unit price.
+     * @param txBuildingProps
+     * @returns
+     */
+    private getProcessedTransactionParams;
+    private _generateVersionedTransaction;
+    generateLegacyVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], wallet?: IWallet): VersionedTransaction;
+    generateVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], wallet?: IWallet): VersionedTransaction;
+    generateLegacyTransaction(ixs: TransactionInstruction[], recentBlockhash?: BlockhashWithExpiryBlockHeight): Transaction;
+    /**
+     * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
+     * @param props
+     * @returns
+     */
+    buildBulkTransactions(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructions: (TransactionInstruction | TransactionInstruction[])[];
+    }): Promise<(Transaction | VersionedTransaction)[]>;
+    /**
+     *
+     * @param instructions
+     * @param txParams
+     * @param txVersion
+     * @param lookupTables
+     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+     * @returns
+     */
+    buildTransaction(props: TxBuildingProps): Promise<Transaction | VersionedTransaction>;
+    wrapInTx(instruction: TransactionInstruction, computeUnits?: number, computeUnitsPrice?: number): Transaction;
+    /**
+     * Get a map of signed and prepared transactions from an array of legacy transactions
+     * @param txsToSign
+     * @param keys
+     * @param wallet
+     * @param commitment
+     * @returns
+     */
+    getPreparedAndSignedLegacyTransactionMap<T extends Record<string, Transaction | undefined>>(txsMap: T, wallet?: IWallet, commitment?: Commitment, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
+    }>;
+    /**
+     * Get a map of signed transactions from an array of transactions to sign.
+     * @param txsToSign
+     * @param keys
+     * @param wallet
+     * @returns
+     */
+    getSignedTransactionMap<T extends Record<string, Transaction | VersionedTransaction | undefined>>(txsToSignMap: T, wallet?: IWallet): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
+    }>;
+    /**
+     * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
+     * @param props
+     * @returns
+     */
+    buildTransactionsMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
+    }): Promise<MappedRecord<T, Transaction | VersionedTransaction>>;
+    /**
+     * Builds and signs transactions from a given array of instructions for multiple transactions.
+     * @param props
+     * @returns
+     */
+    buildAndSignTransactionMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
+    }): Promise<{
+        signedTxMap: Record<string, Transaction>;
+        signedTxData: SignedTxData[];
+    } | {
+        signedTxMap: MappedRecord<T, Transaction | VersionedTransaction>;
+        signedTxData: SignedTxData[];
+    }>;
+    simulateAndCalculateInstructions(txBuildingProps: TxBuildingProps, optionalInstructions?: TransactionInstruction[], versionedTransaction?: boolean, addressLookupTables?: AddressLookupTableAccount[]): Promise<[
+        TransactionInstruction[],
+        SimulatedTransactionResponse | undefined
+    ]>;
+}