@drift-labs/sdk 2.82.0-beta.19 → 2.82.0-beta.20

package/lib/tx/baseTxSender.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
-import { ConfirmationStrategy, ExtraConfirmationOptions, TxSender, TxSigAndSlot } from './types';
-import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount } from '@solana/web3.js';
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction } from '@solana/web3.js';
+import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
 export declare abstract class BaseTxSender implements TxSender {
     connection: Connection;
@@ -11,7 +12,8 @@ export declare abstract class BaseTxSender implements TxSender {
     timeoutCount: number;
     confirmationStrategy: ConfirmationStrategy;
     additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
-    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, }: {
+    txHandler: TxHandler;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, txHandler, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -19,11 +21,11 @@ export declare abstract class BaseTxSender implements TxSender {
         additionalConnections?: any;
         confirmationStrategy?: ConfirmationStrategy;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler: TxHandler;
     });
-    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
+    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?: string): Promise<VersionedTransaction>;
-    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean, extraConfirmationOptions?: ExtraConfirmationOptions): Promise<TxSigAndSlot>;
+    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>>;

package/lib/tx/baseTxSender.js

@@ -5,14 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseTxSender = void 0;
 const types_1 = require("./types");
-const web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("@coral-xyz/anchor");
 const assert_1 = __importDefault(require("assert"));
 const bs58_1 = __importDefault(require("bs58"));
 const DEFAULT_TIMEOUT = 35000;
 const NOT_CONFIRMED_ERROR_CODE = -1001;
 class BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, }) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks, txHandler, }) {
         this.timeoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;
@@ -21,8 +20,9 @@ class BaseTxSender {
         this.additionalConnections = additionalConnections;
         this.confirmationStrategy = confirmationStrategy;
         this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
+        this.txHandler = txHandler;
     }
-    async send(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
+    async send(tx, additionalSigners, opts, preSigned) {
         if (additionalSigners === undefined) {
             additionalSigners = [];
         }
@@ -30,48 +30,12 @@ class BaseTxSender {
             opts = this.opts;
         }
         const signedTx = await this.prepareTx(tx, additionalSigners, opts, preSigned);
-        if (extraConfirmationOptions === null || extraConfirmationOptions === void 0 ? void 0 : extraConfirmationOptions.onSignedCb) {
-            extraConfirmationOptions.onSignedCb();
-        }
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
     async prepareTx(tx, additionalSigners, opts, preSigned) {
-        if (preSigned) {
-            return tx;
-        }
-        tx.feePayer = this.wallet.publicKey;
-        tx.recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
-        additionalSigners
-            .filter((s) => s !== undefined)
-            .forEach((kp) => {
-            tx.partialSign(kp);
-        });
-        const signedTx = await this.wallet.signTransaction(tx);
-        return signedTx;
+        return this.txHandler.prepareTx(tx, additionalSigners, undefined, opts, preSigned);
     }
-    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
-        if (additionalSigners === undefined) {
-            additionalSigners = [];
-        }
-        if (opts === undefined) {
-            opts = this.opts;
-        }
-        let recentBlockhash = '';
-        if (blockhash) {
-            recentBlockhash = blockhash;
-        }
-        else {
-            recentBlockhash = (await this.connection.getLatestBlockhash(opts.preflightCommitment)).blockhash;
-        }
-        const message = new web3_js_1.TransactionMessage({
-            payerKey: this.wallet.publicKey,
-            recentBlockhash,
-            instructions: ixs,
-        }).compileToV0Message(lookupTableAccounts);
-        const tx = new web3_js_1.VersionedTransaction(message);
-        return tx;
-    }
-    async sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
+    async sendVersionedTransaction(tx, additionalSigners, opts, preSigned) {
         let signedTx;
         if (preSigned) {
             signedTx = tx;
@@ -83,14 +47,7 @@ class BaseTxSender {
             signedTx = tx;
         }
         else {
-            additionalSigners === null || additionalSigners === void 0 ? void 0 : additionalSigners.filter((s) => s !== undefined).forEach((kp) => {
-                tx.sign([kp]);
-            });
-            // @ts-ignore
-            signedTx = await this.wallet.signTransaction(tx);
-        }
-        if (extraConfirmationOptions === null || extraConfirmationOptions === void 0 ? void 0 : extraConfirmationOptions.onSignedCb) {
-            extraConfirmationOptions.onSignedCb();
+            signedTx = await this.txHandler.signVersionedTx(tx, additionalSigners, undefined, this.wallet);
         }
         if (opts === undefined) {
             opts = this.opts;

package/lib/tx/fastSingleTxSender.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import { ConfirmOptions, Signer, Transaction, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, Commitment } from '@solana/web3.js';
-import { IWallet } 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;
@@ -12,11 +13,11 @@ export declare class FastSingleTxSender extends BaseTxSender {
     blockhashRefreshInterval: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    recentBlockhash: string;
+    recentBlockhash: BlockhashWithExpiryBlockHeight;
     skipConfirmation: boolean;
     blockhashCommitment: Commitment;
     blockhashIntervalId: NodeJS.Timer;
-    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, blockhashCommitment, confirmationStrategy, }: {
+    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, blockhashCommitment, confirmationStrategy, txHandler, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -26,9 +27,8 @@ export declare class FastSingleTxSender extends BaseTxSender {
         skipConfirmation?: boolean;
         blockhashCommitment?: Commitment;
         confirmationStrategy?: ConfirmationStrategy;
+        txHandler: TxHandler;
     });
     startBlockhashRefreshLoop(): void;
-    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
-    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: string): Promise<VersionedTransaction>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
 }

package/lib/tx/fastSingleTxSender.js

@@ -2,13 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FastSingleTxSender = void 0;
 const types_1 = require("./types");
-const web3_js_1 = require("@solana/web3.js");
 const anchor_1 = require("@coral-xyz/anchor");
 const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_BLOCKHASH_REFRESH = 10000;
 class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, txHandler, }) {
         super({
             connection,
             wallet,
@@ -16,6 +15,7 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
             timeout,
             additionalConnections,
             confirmationStrategy,
+            txHandler,
         });
         this.timoutCount = 0;
         this.connection = connection;
@@ -32,7 +32,7 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
         if (this.blockhashRefreshInterval > 0) {
             this.blockhashIntervalId = setInterval(async () => {
                 try {
-                    this.recentBlockhash = (await this.connection.getLatestBlockhash(this.blockhashCommitment)).blockhash;
+                    this.recentBlockhash = await this.connection.getLatestBlockhash(this.blockhashCommitment);
                 }
                 catch (e) {
                     console.error('Error in startBlockhashRefreshLoop: ', e);
@@ -40,34 +40,6 @@ class FastSingleTxSender extends baseTxSender_1.BaseTxSender {
             }, this.blockhashRefreshInterval);
         }
     }
-    async prepareTx(tx, additionalSigners, _opts, preSigned) {
-        return super.prepareTx(tx, additionalSigners, _opts, preSigned);
-    }
-    async getVersionedTransaction(ixs, lookupTableAccounts, additionalSigners, opts, blockhash) {
-        var _a;
-        if (additionalSigners === undefined) {
-            additionalSigners = [];
-        }
-        if (opts === undefined) {
-            opts = this.opts;
-        }
-        let recentBlockhash = '';
-        if (blockhash) {
-            recentBlockhash = blockhash;
-        }
-        else {
-            recentBlockhash =
-                (_a = this.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.connection.getLatestBlockhash(opts.preflightCommitment))
-                    .blockhash;
-        }
-        const message = new web3_js_1.TransactionMessage({
-            payerKey: this.wallet.publicKey,
-            recentBlockhash,
-            instructions: ixs,
-        }).compileToV0Message(lookupTableAccounts);
-        const tx = new web3_js_1.VersionedTransaction(message);
-        return tx;
-    }
     async sendRawTransaction(rawTransaction, opts) {
         let txid;
         try {

package/lib/tx/forwardOnlyTxSender.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
 import { ConfirmOptions, Connection } from '@solana/web3.js';
-import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
 import { ConfirmationStrategy, TxSigAndSlot } from './types';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
 type ResolveReference = {
     resolve?: () => void;
 };
@@ -14,7 +15,7 @@ export declare class ForwardOnlyTxSender extends BaseTxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor({ connection, wallet, opts, timeout, retrySleep, confirmationStrategy, additionalTxSenderCallbacks, }: {
+    constructor({ connection, wallet, opts, timeout, retrySleep, confirmationStrategy, additionalTxSenderCallbacks, txHandler, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -22,6 +23,7 @@ export declare class ForwardOnlyTxSender extends BaseTxSender {
         retrySleep?: number;
         confirmationStrategy?: ConfirmationStrategy;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler: TxHandler;
     });
     sleep(reference: ResolveReference): Promise<void>;
     sendToAdditionalConnections(rawTx: Buffer | Uint8Array, _opts: ConfirmOptions): void;

package/lib/tx/forwardOnlyTxSender.js

@@ -12,7 +12,7 @@ const types_1 = require("./types");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 5000;
 class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, }) {
         super({
             connection,
             wallet,
@@ -21,6 +21,7 @@ class ForwardOnlyTxSender extends baseTxSender_1.BaseTxSender {
             additionalConnections: [],
             confirmationStrategy,
             additionalTxSenderCallbacks,
+            txHandler,
         });
         this.timoutCount = 0;
         this.connection = connection;

package/lib/tx/retryTxSender.d.ts

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

package/lib/tx/retryTxSender.js

@@ -7,7 +7,7 @@ const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 2000;
 class RetryTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], }) {
+    constructor({ connection, wallet, opts = { ...anchor_1.AnchorProvider.defaultOptions(), maxRetries: 0 }, timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, }) {
         super({
             connection,
             wallet,
@@ -16,6 +16,7 @@ class RetryTxSender extends baseTxSender_1.BaseTxSender {
             additionalConnections,
             confirmationStrategy,
             additionalTxSenderCallbacks,
+            txHandler,
         });
         this.timoutCount = 0;
         this.connection = connection;

package/lib/tx/txHandler.d.ts

@@ -0,0 +1,138 @@
+import { AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, Commitment, ConfirmOptions, Connection, Signer, Transaction, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { DriftClientMetricsEvents, IWallet, TxParams } from '../types';
+export declare const COMPUTE_UNITS_DEFAULT = 200000;
+export type TxBuildingProps = {
+    instructions: TransactionInstruction | TransactionInstruction[];
+    txVersion: TransactionVersion;
+    connection: Connection;
+    preFlightCommitment: Commitment;
+    fetchMarketLookupTableAccount: () => Promise<AddressLookupTableAccount>;
+    lookupTables?: AddressLookupTableAccount[];
+    forceVersionedTransaction?: boolean;
+    txParams?: TxParams;
+    recentBlockHash?: BlockhashWithExpiryBlockHeight;
+    wallet?: IWallet;
+};
+/**
+ * This class is responsible for creating and signing transactions.
+ */
+export declare class TxHandler {
+    private blockHashToLastValidBlockHeightLookup;
+    private returnBlockHeightsWithSignedTxCallbackData;
+    private connection;
+    private wallet;
+    private confirmationOptions;
+    private onSignedCb?;
+    constructor(props: {
+        connection: Connection;
+        wallet: IWallet;
+        confirmationOptions: ConfirmOptions;
+        opts?: {
+            returnBlockHeightsWithSignedTxCallbackData?: boolean;
+            onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
+        };
+    });
+    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 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[]): 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;
+    /**
+     * Build a map of transactions from an array of instructions for multiple transactions.
+     * @param txsToSign
+     * @param keys
+     * @param wallet
+     * @param commitment
+     * @returns
+     */
+    buildTransactionMap(txsToSign: (Transaction | undefined)[], keys: string[], wallet?: IWallet, commitment?: Commitment, recentBlockHash?: BlockhashWithExpiryBlockHeight): Promise<{
+        [key: string]: Transaction | VersionedTransaction;
+    }>;
+    /**
+     * Get a map of signed and prepared transactions from an array of legacy transactions
+     * @param txsToSign
+     * @param keys
+     * @param wallet
+     * @param commitment
+     * @returns
+     */
+    getPreparedAndSignedLegacyTransactionMap(txsToSign: (Transaction | undefined)[], keys: string[], wallet?: IWallet, commitment?: Commitment, recentBlockHash?: BlockhashWithExpiryBlockHeight): Promise<{
+        [key: string]: Transaction | VersionedTransaction;
+    }>;
+    /**
+     * Get a map of signed transactions from an array of transactions to sign.
+     * @param txsToSign
+     * @param keys
+     * @param wallet
+     * @returns
+     */
+    getSignedTransactionMap(txsToSign: (Transaction | VersionedTransaction | undefined)[], keys: string[], wallet?: IWallet): Promise<{
+        [key: string]: Transaction | VersionedTransaction | undefined;
+    }>;
+    /**
+     * Builds and signs transactions from a given array of instructions for multiple transactions.
+     * @param props
+     * @returns
+     */
+    buildAndSignTransactionMap(props: Omit<TxBuildingProps, 'instructions'> & {
+        keys: string[];
+        instructions: (TransactionInstruction | TransactionInstruction[])[];
+    }): Promise<{
+        [key: string]: Transaction | VersionedTransaction;
+    }>;
+}