@drift-labs/sdk 2.53.0-beta.9 → 2.54.0-beta.1

package/VERSION

@@ -1 +1 @@
-2.53.0-beta.9
+2.54.0-beta.1

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.52.0",
+    "version": "2.53.0",
     "name": "drift",
     "instructions": [
         {

package/lib/tx/baseTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSender, TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
 import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount } from '@solana/web3.js';
 import { IWallet } from '../types';
 export declare abstract class BaseTxSender implements TxSender {
@@ -9,18 +9,22 @@ export declare abstract class BaseTxSender implements TxSender {
     timeout: number;
     additionalConnections: Connection[];
     timeoutCount: number;
-    constructor({ connection, wallet, opts, timeout, additionalConnections, }: {
+    confirmationStrategy: ConfirmationStrategy;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
         timeout?: number;
         additionalConnections?: any;
+        confirmationStrategy?: ConfirmationStrategy;
     });
     send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions): Promise<Transaction>;
     getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], additionalSigners?: Array<Signer>, opts?: ConfirmOptions): Promise<VersionedTransaction>;
     sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+    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>;

package/lib/tx/baseTxSender.js

@@ -4,19 +4,21 @@ 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;
 class BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), }) {
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
         this.timeoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;
         this.opts = opts;
         this.timeout = timeout;
         this.additionalConnections = additionalConnections;
+        this.confirmationStrategy = confirmationStrategy;
     }
     async send(tx, additionalSigners, opts, preSigned) {
         if (additionalSigners === undefined) {
@@ -86,7 +88,8 @@ class BaseTxSender {
     opts) {
         throw new Error('Must be implemented by subclass');
     }
-    async confirmTransaction(signature, commitment) {
+    async confirmTransactionWebSocket(signature, commitment) {
+        var _a;
         let decodedSignature;
         try {
             decodedSignature = bs58_1.default.decode(signature);
@@ -131,12 +134,54 @@ class BaseTxSender {
             }
         }
         if (response === null) {
+            if (this.confirmationStrategy === types_1.ConfirmationStrategy.Combo) {
+                try {
+                    const rpcResponse = await this.connection.getSignatureStatus(signature);
+                    if ((_a = rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value) === null || _a === void 0 ? void 0 : _a.confirmationStatus) {
+                        response = {
+                            context: rpcResponse.context,
+                            value: { err: rpcResponse.value.err },
+                        };
+                        return response;
+                    }
+                }
+                catch (error) {
+                    // Ignore error to pass through to timeout error
+                }
+            }
             this.timeoutCount += 1;
             const duration = (Date.now() - start) / 1000;
             throw new Error(`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.`);
         }
         return response;
     }
+    async confirmTransactionPolling(signature, commitment = 'finalized') {
+        var _a;
+        let totalTime = 0;
+        let backoffTime = 250;
+        while (totalTime < this.timeout) {
+            const response = await this.connection.getSignatureStatus(signature);
+            const result = response && ((_a = response.value) === null || _a === void 0 ? void 0 : _a[0]);
+            if (result && result.confirmationStatus === commitment) {
+                return { context: result.context, value: { err: null } };
+            }
+            await new Promise((resolve) => setTimeout(resolve, backoffTime));
+            totalTime += backoffTime;
+            backoffTime = Math.min(backoffTime * 2, 5000);
+        }
+        // Transaction not confirmed within 30 seconds
+        this.timeoutCount += 1;
+        throw new Error(`Transaction was not confirmed in 30 seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
+    }
+    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();
     }

package/lib/tx/fastSingleTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import { ConfirmOptions, Signer, Transaction, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, Commitment } from '@solana/web3.js';
 import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
@@ -14,7 +14,7 @@ export declare class FastSingleTxSender extends BaseTxSender {
     recentBlockhash: string;
     skipConfirmation: boolean;
     blockhashCommitment: Commitment;
-    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, blockhashCommitment, }: {
+    constructor({ connection, wallet, opts, timeout, blockhashRefreshInterval, additionalConnections, skipConfirmation, blockhashCommitment, confirmationStrategy, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
@@ -23,6 +23,7 @@ export declare class FastSingleTxSender extends BaseTxSender {
         additionalConnections?: any;
         skipConfirmation?: boolean;
         blockhashCommitment?: Commitment;
+        confirmationStrategy?: ConfirmationStrategy;
     });
     startBlockhashRefreshLoop(): void;
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, _opts: ConfirmOptions): Promise<Transaction>;

package/lib/tx/fastSingleTxSender.js

@@ -1,14 +1,22 @@
 "use strict";
 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(), timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, blockhashCommitment = 'finalized', }) {
-        super({ connection, wallet, opts, timeout, additionalConnections });
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH, additionalConnections = new Array(), skipConfirmation = false, blockhashCommitment = 'finalized', confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            timeout,
+            additionalConnections,
+            confirmationStrategy,
+        });
         this.timoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;

package/lib/tx/retryTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import { ConfirmOptions, Connection } from '@solana/web3.js';
 import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
@@ -14,13 +14,14 @@ export declare class RetryTxSender extends BaseTxSender {
     retrySleep: number;
     additionalConnections: Connection[];
     timoutCount: number;
-    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, }: {
+    constructor({ connection, wallet, opts, timeout, retrySleep, additionalConnections, confirmationStrategy, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
         timeout?: number;
         retrySleep?: number;
         additionalConnections?: any;
+        confirmationStrategy?: ConfirmationStrategy;
     });
     sleep(reference: ResolveReference): Promise<void>;
     sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;

package/lib/tx/retryTxSender.js

@@ -1,13 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryTxSender = void 0;
+const types_1 = require("./types");
 const anchor_1 = require("@coral-xyz/anchor");
 const baseTxSender_1 = require("./baseTxSender");
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
 class RetryTxSender extends baseTxSender_1.BaseTxSender {
-    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), }) {
-        super({ connection, wallet, opts, timeout, additionalConnections });
+    constructor({ connection, wallet, opts = anchor_1.AnchorProvider.defaultOptions(), timeout = DEFAULT_TIMEOUT, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, }) {
+        super({
+            connection,
+            wallet,
+            opts,
+            timeout,
+            additionalConnections,
+            confirmationStrategy,
+        });
         this.timoutCount = 0;
         this.connection = connection;
         this.wallet = wallet;

package/lib/tx/types.d.ts

@@ -1,6 +1,11 @@
 /// <reference types="node" />
 import { AddressLookupTableAccount, ConfirmOptions, Signer, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
 import { IWallet } from '../types';
+export declare enum ConfirmationStrategy {
+    WebSocket = "websocket",
+    Polling = "polling",
+    Combo = "combo"
+}
 export type TxSigAndSlot = {
     txSig: TransactionSignature;
     slot: number;

package/lib/tx/types.js

@@ -1,2 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationStrategy = void 0;
+var ConfirmationStrategy;
+(function (ConfirmationStrategy) {
+    ConfirmationStrategy["WebSocket"] = "websocket";
+    ConfirmationStrategy["Polling"] = "polling";
+    ConfirmationStrategy["Combo"] = "combo";
+})(ConfirmationStrategy = exports.ConfirmationStrategy || (exports.ConfirmationStrategy = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.53.0-beta.9",
+	"version": "2.54.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.52.0",
+  "version": "2.53.0",
   "name": "drift",
   "instructions": [
     {

package/src/tx/baseTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSender, TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
 import {
 	Commitment,
 	ConfirmOptions,
@@ -28,6 +28,7 @@ export abstract class BaseTxSender implements TxSender {
 	timeout: number;
 	additionalConnections: Connection[];
 	timeoutCount = 0;
+	confirmationStrategy: ConfirmationStrategy;
 
 	public constructor({
 		connection,
@@ -35,18 +36,21 @@ export abstract class BaseTxSender implements TxSender {
 		opts = AnchorProvider.defaultOptions(),
 		timeout = DEFAULT_TIMEOUT,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
 		opts?: ConfirmOptions;
 		timeout?: number;
 		additionalConnections?;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;
 		this.timeout = timeout;
 		this.additionalConnections = additionalConnections;
+		this.confirmationStrategy = confirmationStrategy;
 	}
 
 	async send(
@@ -156,7 +160,7 @@ export abstract class BaseTxSender implements TxSender {
 		throw new Error('Must be implemented by subclass');
 	}
 
-	async confirmTransaction(
+	async confirmTransactionWebSocket(
 		signature: TransactionSignature,
 		commitment?: Commitment
 	): Promise<RpcResponseAndContext<SignatureResult>> {
@@ -210,6 +214,22 @@ export abstract class BaseTxSender implements TxSender {
 		}
 
 		if (response === null) {
+			if (this.confirmationStrategy === ConfirmationStrategy.Combo) {
+				try {
+					const rpcResponse = await this.connection.getSignatureStatus(
+						signature
+					);
+					if (rpcResponse?.value?.confirmationStatus) {
+						response = {
+							context: rpcResponse.context,
+							value: { err: rpcResponse.value.err },
+						};
+						return response;
+					}
+				} catch (error) {
+					// Ignore error to pass through to timeout error
+				}
+			}
 			this.timeoutCount += 1;
 			const duration = (Date.now() - start) / 1000;
 			throw new Error(
@@ -222,6 +242,47 @@ export abstract class BaseTxSender implements TxSender {
 		return response;
 	}
 
+	async confirmTransactionPolling(
+		signature: TransactionSignature,
+		commitment: Commitment = 'finalized'
+	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
+		let totalTime = 0;
+		let backoffTime = 250;
+
+		while (totalTime < this.timeout) {
+			const response = await this.connection.getSignatureStatus(signature);
+			const result = response && response.value?.[0];
+
+			if (result && result.confirmationStatus === commitment) {
+				return { context: result.context, value: { err: null } };
+			}
+
+			await new Promise((resolve) => setTimeout(resolve, backoffTime));
+			totalTime += backoffTime;
+			backoffTime = Math.min(backoffTime * 2, 5000);
+		}
+
+		// Transaction not confirmed within 30 seconds
+		this.timeoutCount += 1;
+		throw new Error(
+			`Transaction was not confirmed in 30 seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`
+		);
+	}
+
+	async confirmTransaction(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		if (
+			this.confirmationStrategy === ConfirmationStrategy.WebSocket ||
+			this.confirmationStrategy === ConfirmationStrategy.Combo
+		) {
+			return await this.confirmTransactionWebSocket(signature, commitment);
+		} else if (this.confirmationStrategy === ConfirmationStrategy.Polling) {
+			return await this.confirmTransactionPolling(signature, commitment);
+		}
+	}
+
 	getTimestamp(): number {
 		return new Date().getTime();
 	}

package/src/tx/fastSingleTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import {
 	ConfirmOptions,
 	Signer,
@@ -39,6 +39,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		additionalConnections = new Array<Connection>(),
 		skipConfirmation = false,
 		blockhashCommitment = 'finalized',
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -48,8 +49,16 @@ export class FastSingleTxSender extends BaseTxSender {
 		additionalConnections?;
 		skipConfirmation?: boolean;
 		blockhashCommitment?: Commitment;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
-		super({ connection, wallet, opts, timeout, additionalConnections });
+		super({
+			connection,
+			wallet,
+			opts,
+			timeout,
+			additionalConnections,
+			confirmationStrategy,
+		});
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;

package/src/tx/retryTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import {
 	ConfirmOptions,
 	TransactionSignature,
@@ -31,6 +31,7 @@ export class RetryTxSender extends BaseTxSender {
 		timeout = DEFAULT_TIMEOUT,
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -38,8 +39,16 @@ export class RetryTxSender extends BaseTxSender {
 		timeout?: number;
 		retrySleep?: number;
 		additionalConnections?;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
-		super({ connection, wallet, opts, timeout, additionalConnections });
+		super({
+			connection,
+			wallet,
+			opts,
+			timeout,
+			additionalConnections,
+			confirmationStrategy,
+		});
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;

package/src/tx/types.ts

@@ -9,6 +9,12 @@ import {
 } from '@solana/web3.js';
 import { IWallet } from '../types';
 
+export enum ConfirmationStrategy {
+	WebSocket = 'websocket',
+	Polling = 'polling',
+	Combo = 'combo',
+}
+
 export type TxSigAndSlot = {
 	txSig: TransactionSignature;
 	slot: number;