@drift-labs/sdk 2.96.0-beta.25 → 2.96.0-beta.26

package/VERSION

@@ -1 +1 @@
-2.96.0-beta.25
+2.96.0-beta.26

package/lib/config.d.ts

@@ -26,6 +26,7 @@ export type DriftEnv = 'devnet' | 'mainnet-beta';
 export declare const DRIFT_PROGRAM_ID = "dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH";
 export declare const DRIFT_ORACLE_RECEIVER_ID = "G6EoTTTgpkNBtVXo96EQp2m6uwwVh2Kt6YidjkmQqoha";
 export declare const SWIFT_ID = "SW1fThqrxLzVprnCMpiybiqYQfoNCdduC5uWsSUKChS";
+export declare const ANCHOR_TEST_SWIFT_ID = "DpaEdAPW3ZX67fnczT14AoX12Lx9VMkxvtT81nCHy3Nv";
 export declare const DEFAULT_CONFIRMATION_OPTS: ConfirmOptions;
 export declare const configs: {
     [key in DriftEnv]: DriftConfig;

package/lib/config.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllMarketAndOracles = exports.getMarketsAndOraclesForSubscription = exports.initialize = exports.getConfig = exports.configs = exports.DEFAULT_CONFIRMATION_OPTS = exports.SWIFT_ID = exports.DRIFT_ORACLE_RECEIVER_ID = exports.DRIFT_PROGRAM_ID = void 0;
+exports.findAllMarketAndOracles = exports.getMarketsAndOraclesForSubscription = exports.initialize = exports.getConfig = exports.configs = exports.DEFAULT_CONFIRMATION_OPTS = exports.ANCHOR_TEST_SWIFT_ID = exports.SWIFT_ID = exports.DRIFT_ORACLE_RECEIVER_ID = exports.DRIFT_PROGRAM_ID = void 0;
 const perpMarkets_1 = require("./constants/perpMarkets");
 const spotMarkets_1 = require("./constants/spotMarkets");
 const on_demand_1 = require("@switchboard-xyz/on-demand");
 exports.DRIFT_PROGRAM_ID = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
 exports.DRIFT_ORACLE_RECEIVER_ID = 'G6EoTTTgpkNBtVXo96EQp2m6uwwVh2Kt6YidjkmQqoha';
 exports.SWIFT_ID = 'SW1fThqrxLzVprnCMpiybiqYQfoNCdduC5uWsSUKChS';
+exports.ANCHOR_TEST_SWIFT_ID = 'DpaEdAPW3ZX67fnczT14AoX12Lx9VMkxvtT81nCHy3Nv';
 exports.DEFAULT_CONFIRMATION_OPTS = {
     preflightCommitment: 'confirmed',
     commitment: 'confirmed',

package/lib/constants/perpMarkets.js

@@ -263,7 +263,7 @@ exports.DevnetPerpMarkets = [
         symbol: 'W-PERP',
         baseAssetSymbol: 'W',
         marketIndex: 23,
-        oracle: new web3_js_1.PublicKey('4iCi4DvXrubHQne8jzbMaWL3pd7v1Fip8iTe4H9vHNXB'),
+        oracle: new web3_js_1.PublicKey('J9nrFWjDUeDVZ4BhhxsbQXWgLcLEgQyNBrCbwSADmJdr'),
         launchTs: 1709852537000,
         oracleSource: __1.OracleSource.SWITCHBOARD_ON_DEMAND,
         pythFeedId: '0xeff7446475e218517566ea99e72a4abec2e1bd8498b43b7d8331e29dcb059389',

package/lib/constants/txConstants.d.ts

@@ -0,0 +1 @@
+export declare const NOT_CONFIRMED_ERROR_CODE = -1001;

package/lib/constants/txConstants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOT_CONFIRMED_ERROR_CODE = void 0;
+exports.NOT_CONFIRMED_ERROR_CODE = -1001;

package/lib/driftClient.d.ts

@@ -37,6 +37,7 @@ export declare class DriftClient {
     connection: Connection;
     wallet: IWallet;
     program: Program;
+    swiftID: PublicKey;
     provider: AnchorProvider;
     opts?: ConfirmOptions;
     users: Map<string, User>;

package/lib/driftClient.js

@@ -80,7 +80,7 @@ class DriftClient {
         this._isSubscribed = val;
     }
     constructor(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
         this.users = new Map();
         this._isSubscribed = false;
         this.perpMarketLastSlotCache = new Map();
@@ -98,16 +98,17 @@ class DriftClient {
         // @ts-ignore
         config.wallet, this.opts);
         this.program = new anchor_1.Program(drift_json_1.default, (_c = config.programID) !== null && _c !== void 0 ? _c : new web3_js_1.PublicKey(config_1.DRIFT_PROGRAM_ID), this.provider);
-        this.authority = (_d = config.authority) !== null && _d !== void 0 ? _d : this.wallet.publicKey;
-        this.activeSubAccountId = (_e = config.activeSubAccountId) !== null && _e !== void 0 ? _e : 0;
-        this.skipLoadUsers = (_f = config.skipLoadUsers) !== null && _f !== void 0 ? _f : false;
-        this.txVersion = (_g = config.txVersion) !== null && _g !== void 0 ? _g : 'legacy';
+        this.swiftID = (_d = config.swiftID) !== null && _d !== void 0 ? _d : new web3_js_1.PublicKey(config_1.SWIFT_ID);
+        this.authority = (_e = config.authority) !== null && _e !== void 0 ? _e : this.wallet.publicKey;
+        this.activeSubAccountId = (_f = config.activeSubAccountId) !== null && _f !== void 0 ? _f : 0;
+        this.skipLoadUsers = (_g = config.skipLoadUsers) !== null && _g !== void 0 ? _g : false;
+        this.txVersion = (_h = config.txVersion) !== null && _h !== void 0 ? _h : 'legacy';
         this.txParams = {
-            computeUnits: (_j = (_h = config.txParams) === null || _h === void 0 ? void 0 : _h.computeUnits) !== null && _j !== void 0 ? _j : 600000,
-            computeUnitsPrice: (_l = (_k = config.txParams) === null || _k === void 0 ? void 0 : _k.computeUnitsPrice) !== null && _l !== void 0 ? _l : 0,
+            computeUnits: (_k = (_j = config.txParams) === null || _j === void 0 ? void 0 : _j.computeUnits) !== null && _k !== void 0 ? _k : 600000,
+            computeUnitsPrice: (_m = (_l = config.txParams) === null || _l === void 0 ? void 0 : _l.computeUnitsPrice) !== null && _m !== void 0 ? _m : 0,
         };
         this.txHandler =
-            (_m = config === null || config === void 0 ? void 0 : config.txHandler) !== null && _m !== void 0 ? _m : new txHandler_1.TxHandler({
+            (_o = config === null || config === void 0 ? void 0 : config.txHandler) !== null && _o !== void 0 ? _o : new txHandler_1.TxHandler({
                 connection: this.connection,
                 // @ts-ignore
                 wallet: this.provider.wallet,
@@ -133,8 +134,8 @@ class DriftClient {
             : config.subAccountIds
                 ? new Map([[this.authority.toString(), config.subAccountIds]])
                 : new Map();
-        this.includeDelegates = (_o = config.includeDelegates) !== null && _o !== void 0 ? _o : false;
-        if (((_p = config.accountSubscription) === null || _p === void 0 ? void 0 : _p.type) === 'polling') {
+        this.includeDelegates = (_p = config.includeDelegates) !== null && _p !== void 0 ? _p : false;
+        if (((_q = config.accountSubscription) === null || _q === void 0 ? void 0 : _q.type) === 'polling') {
             this.userAccountSubscriptionConfig = {
                 type: 'polling',
                 accountLoader: config.accountSubscription.accountLoader,
@@ -147,15 +148,15 @@ class DriftClient {
         else {
             this.userAccountSubscriptionConfig = {
                 type: 'websocket',
-                resubTimeoutMs: (_q = config.accountSubscription) === null || _q === void 0 ? void 0 : _q.resubTimeoutMs,
-                logResubMessages: (_r = config.accountSubscription) === null || _r === void 0 ? void 0 : _r.logResubMessages,
-                commitment: (_s = config.accountSubscription) === null || _s === void 0 ? void 0 : _s.commitment,
+                resubTimeoutMs: (_r = config.accountSubscription) === null || _r === void 0 ? void 0 : _r.resubTimeoutMs,
+                logResubMessages: (_s = config.accountSubscription) === null || _s === void 0 ? void 0 : _s.logResubMessages,
+                commitment: (_t = config.accountSubscription) === null || _t === void 0 ? void 0 : _t.commitment,
             };
             this.userStatsAccountSubscriptionConfig = {
                 type: 'websocket',
-                resubTimeoutMs: (_t = config.accountSubscription) === null || _t === void 0 ? void 0 : _t.resubTimeoutMs,
-                logResubMessages: (_u = config.accountSubscription) === null || _u === void 0 ? void 0 : _u.logResubMessages,
-                commitment: (_v = config.accountSubscription) === null || _v === void 0 ? void 0 : _v.commitment,
+                resubTimeoutMs: (_u = config.accountSubscription) === null || _u === void 0 ? void 0 : _u.resubTimeoutMs,
+                logResubMessages: (_v = config.accountSubscription) === null || _v === void 0 ? void 0 : _v.logResubMessages,
+                commitment: (_w = config.accountSubscription) === null || _w === void 0 ? void 0 : _w.commitment,
             };
         }
         if (config.userStats) {
@@ -173,14 +174,14 @@ class DriftClient {
         const noMarketsAndOraclesSpecified = config.perpMarketIndexes === undefined &&
             config.spotMarketIndexes === undefined &&
             config.oracleInfos === undefined;
-        if (((_w = config.accountSubscription) === null || _w === void 0 ? void 0 : _w.type) === 'polling') {
-            this.accountSubscriber = new pollingDriftClientAccountSubscriber_1.PollingDriftClientAccountSubscriber(this.program, config.accountSubscription.accountLoader, (_x = config.perpMarketIndexes) !== null && _x !== void 0 ? _x : [], (_y = config.spotMarketIndexes) !== null && _y !== void 0 ? _y : [], (_z = config.oracleInfos) !== null && _z !== void 0 ? _z : [], noMarketsAndOraclesSpecified, delistedMarketSetting);
+        if (((_x = config.accountSubscription) === null || _x === void 0 ? void 0 : _x.type) === 'polling') {
+            this.accountSubscriber = new pollingDriftClientAccountSubscriber_1.PollingDriftClientAccountSubscriber(this.program, config.accountSubscription.accountLoader, (_y = config.perpMarketIndexes) !== null && _y !== void 0 ? _y : [], (_z = config.spotMarketIndexes) !== null && _z !== void 0 ? _z : [], (_0 = config.oracleInfos) !== null && _0 !== void 0 ? _0 : [], noMarketsAndOraclesSpecified, delistedMarketSetting);
         }
         else {
-            this.accountSubscriber = new webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber(this.program, (_0 = config.perpMarketIndexes) !== null && _0 !== void 0 ? _0 : [], (_1 = config.spotMarketIndexes) !== null && _1 !== void 0 ? _1 : [], (_2 = config.oracleInfos) !== null && _2 !== void 0 ? _2 : [], noMarketsAndOraclesSpecified, delistedMarketSetting, {
-                resubTimeoutMs: (_3 = config.accountSubscription) === null || _3 === void 0 ? void 0 : _3.resubTimeoutMs,
-                logResubMessages: (_4 = config.accountSubscription) === null || _4 === void 0 ? void 0 : _4.logResubMessages,
-            }, (_5 = config.accountSubscription) === null || _5 === void 0 ? void 0 : _5.commitment);
+            this.accountSubscriber = new webSocketDriftClientAccountSubscriber_1.WebSocketDriftClientAccountSubscriber(this.program, (_1 = config.perpMarketIndexes) !== null && _1 !== void 0 ? _1 : [], (_2 = config.spotMarketIndexes) !== null && _2 !== void 0 ? _2 : [], (_3 = config.oracleInfos) !== null && _3 !== void 0 ? _3 : [], noMarketsAndOraclesSpecified, delistedMarketSetting, {
+                resubTimeoutMs: (_4 = config.accountSubscription) === null || _4 === void 0 ? void 0 : _4.resubTimeoutMs,
+                logResubMessages: (_5 = config.accountSubscription) === null || _5 === void 0 ? void 0 : _5.logResubMessages,
+            }, (_6 = config.accountSubscription) === null || _6 === void 0 ? void 0 : _6.commitment);
         }
         this.eventEmitter = this.accountSubscriber.eventEmitter;
         this.metricsEventEmitter = new events_1.EventEmitter();
@@ -188,14 +189,14 @@ class DriftClient {
             this.enableMetricsEvents = true;
         }
         this.txSender =
-            (_6 = config.txSender) !== null && _6 !== void 0 ? _6 : new retryTxSender_1.RetryTxSender({
+            (_7 = config.txSender) !== null && _7 !== void 0 ? _7 : new retryTxSender_1.RetryTxSender({
                 connection: this.connection,
                 wallet: this.wallet,
                 opts: this.opts,
                 txHandler: this.txHandler,
             });
         this.sbOnDemandProgramdId =
-            config_1.configs[(_7 = config.env) !== null && _7 !== void 0 ? _7 : 'mainnet-beta'].SB_ON_DEMAND_PID;
+            config_1.configs[(_8 = config.env) !== null && _8 !== void 0 ? _8 : 'mainnet-beta'].SB_ON_DEMAND_PID;
     }
     getUserMapKey(subAccountId, authority) {
         return `${subAccountId}_${authority.toString()}`;
@@ -2956,7 +2957,7 @@ class DriftClient {
             readablePerpMarketIndex: marketIndex,
         });
         const swiftServerSignatureIx = web3_js_1.Ed25519Program.createInstructionWithPublicKey({
-            publicKey: new web3_js_1.PublicKey(config_1.SWIFT_ID).toBytes(),
+            publicKey: new web3_js_1.PublicKey(this.swiftID).toBytes(),
             signature: Uint8Array.from(swiftSignature),
             message: Uint8Array.from(encodedSwiftServerMessage),
         });

package/lib/driftClientConfig.d.ts

@@ -11,6 +11,7 @@ export type DriftClientConfig = {
     wallet: IWallet;
     env?: DriftEnv;
     programID?: PublicKey;
+    swiftID?: PublicKey;
     accountSubscription?: DriftClientSubscriptionConfig;
     opts?: ConfirmOptions;
     txSender?: TxSender;

package/lib/tx/baseTxSender.d.ts

@@ -48,7 +48,6 @@ export declare abstract class BaseTxSender implements TxSender {
     addAdditionalConnection(newConnection: Connection): void;
     getTimeoutCount(): number;
     checkConfirmationResultForError(txSig: string, result: SignatureResult): Promise<void>;
-    reportTransactionError(txSig: string): Promise<any>;
     getTxLandRate(): number;
     private defaultLandRateToFeeFunc;
     getSuggestedPriorityFeeMultiplier(): number;

package/lib/tx/baseTxSender.js

@@ -5,16 +5,16 @@ 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 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;
-const NOT_CONFIRMED_ERROR_CODE = -1001;
 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, }) {
         this.timeoutCount = 0;
@@ -166,7 +166,7 @@ class BaseTxSender {
             }
             this.timeoutCount += 1;
             const duration = (Date.now() - start) / 1000;
-            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.`, NOT_CONFIRMED_ERROR_CODE);
+            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;
     }
@@ -192,7 +192,7 @@ class BaseTxSender {
         // Transaction not confirmed within 30 seconds
         this.timeoutCount += 1;
         const duration = (Date.now() - start) / 1000;
-        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.`, NOT_CONFIRMED_ERROR_CODE);
+        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 ||
@@ -243,30 +243,12 @@ class BaseTxSender {
         return this.timeoutCount;
     }
     async checkConfirmationResultForError(txSig, result) {
+        var _a;
         if (result.err) {
-            await this.reportTransactionError(txSig);
+            await (0, reportTransactionError_1.throwTransactionError)(txSig, this.connection, (_a = this.opts) === null || _a === void 0 ? void 0 : _a.commitment);
         }
         return;
     }
-    async reportTransactionError(txSig) {
-        var _a, _b;
-        const transactionResult = await this.connection.getTransaction(txSig, {
-            maxSupportedTransactionVersion: 0,
-        });
-        if (!((_a = transactionResult === null || transactionResult === void 0 ? void 0 : transactionResult.meta) === null || _a === void 0 ? void 0 : _a.err)) {
-            return undefined;
-        }
-        const logs = transactionResult.meta.logMessages;
-        const lastLog = logs[logs.length - 1];
-        const friendlyMessage = (_b = lastLog === null || lastLog === void 0 ? void 0 : lastLog.match(/(failed:) (.+)/)) === null || _b === void 0 ? void 0 : _b[2];
-        // @ts-ignore
-        throw new web3_js_1.SendTransactionError({
-            action: 'send',
-            signature: txSig,
-            transactionMessage: `Transaction Failed${friendlyMessage ? `: ${friendlyMessage}` : ''}`,
-            logs,
-        });
-    }
     getTxLandRate() {
         if (!this.trackTxLandRate) {
             console.warn('trackTxLandRate is false, returning default land rate of 0');

package/lib/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/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/tx/whileValidTxSender.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import { ConfirmOptions, Connection, Signer, Transaction, VersionedTransaction } from '@solana/web3.js';
 import { BaseTxSender } from './baseTxSender';
 import { TxHandler } from './txHandler';
@@ -21,13 +21,14 @@ export declare class WhileValidTxSender extends BaseTxSender {
     }>;
     useBlockHeightOffset: boolean;
     private checkAndSetUseBlockHeightOffset;
-    constructor({ connection, wallet, opts, retrySleep, additionalConnections, additionalTxSenderCallbacks, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
+    constructor({ connection, wallet, opts, retrySleep, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }: {
         connection: Connection;
         wallet: IWallet;
         opts?: ConfirmOptions;
         retrySleep?: number;
         additionalConnections?: any;
         additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        confirmationStrategy: ConfirmationStrategy;
         txHandler?: TxHandler;
         trackTxLandRate?: boolean;
         txLandRateLookbackWindowMinutes?: number;

package/lib/tx/whileValidTxSender.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhileValidTxSender = void 0;
+const types_1 = require("./types");
 const web3_js_1 = require("@solana/web3.js");
 const baseTxSender_1 = require("./baseTxSender");
 const bs58_1 = __importDefault(require("bs58"));
@@ -29,7 +30,7 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
             }
         });
     }
-    constructor({ connection, wallet, opts = { ...config_1.DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 }, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
+    constructor({ connection, wallet, opts = { ...config_1.DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 }, retrySleep = DEFAULT_RETRY, additionalConnections = new Array(), confirmationStrategy = types_1.ConfirmationStrategy.Combo, additionalTxSenderCallbacks = [], txHandler, trackTxLandRate, txLandRateLookbackWindowMinutes, landRateToFeeFunc, }) {
         super({
             connection,
             wallet,
@@ -39,6 +40,7 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
             txHandler,
             trackTxLandRate,
             txLandRateLookbackWindowMinutes,
+            confirmationStrategy,
             landRateToFeeFunc,
         });
         this.timoutCount = 0;
@@ -103,13 +105,11 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
         }
         const txSig = bs58_1.default.encode(signedTx.signatures[0]);
         this.untilValid.set(txSig, latestBlockhash);
-        console.debug(`preflight_commitment`, `sending_tx_with_preflight_commitment::${opts === null || opts === void 0 ? void 0 : opts.preflightCommitment}`);
         return this.sendRawTransaction(signedTx.serialize(), opts);
     }
     async sendRawTransaction(rawTransaction, opts) {
         var _a, _b, _c;
         const startTime = this.getTimestamp();
-        console.debug(`preflight_commitment`, `sending_tx_with_preflight_commitment::${opts === null || opts === void 0 ? void 0 : opts.preflightCommitment}`);
         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);

package/lib/types.d.ts

@@ -1103,6 +1103,7 @@ export type SwiftServerMessage = {
 export type SwiftOrderParamsMessage = {
     swiftOrderParams: OptionalOrderParams;
     expectedOrderId: number;
+    subAccountId: number;
     takeProfitOrderParams: SwiftTriggerOrderParams | null;
     stopLossOrderParams: SwiftTriggerOrderParams | null;
 };

package/lib/util/TransactionConfirmationManager.d.ts

@@ -1,4 +1,4 @@
-import { Connection, SignatureStatus, TransactionConfirmationStatus } from '@solana/web3.js';
+import { Connection, RpcResponseAndContext, SignatureResult, SignatureStatus, TransactionConfirmationStatus } from '@solana/web3.js';
 /**
  * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
  */
@@ -7,8 +7,10 @@ export declare class TransactionConfirmationManager {
     private pendingConfirmations;
     private intervalId;
     constructor(connection: Connection);
-    confirmTransaction(txSig: string, desiredConfirmationStatus?: TransactionConfirmationStatus, timeout?: number, pollInterval?: number, searchTransactionHistory?: boolean): Promise<SignatureStatus>;
+    confirmTransactionWebSocket(txSig: string, timeout?: number, desiredConfirmationStatus?: TransactionConfirmationStatus): Promise<RpcResponseAndContext<SignatureResult>>;
+    confirmTransactionPolling(txSig: string, desiredConfirmationStatus?: TransactionConfirmationStatus, timeout?: number, pollInterval?: number, searchTransactionHistory?: boolean): Promise<SignatureStatus>;
     private startConfirmationLoop;
     private checkPendingConfirmations;
+    private checkStatusMatchesDesiredConfirmationStatus;
     private checkTransactionStatuses;
 }

package/lib/util/TransactionConfirmationManager.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionConfirmationManager = void 0;
 const config_1 = require("../config");
+const __1 = require("..");
+const txConstants_1 = require("../constants/txConstants");
+const reportTransactionError_1 = require("../tx/reportTransactionError");
+const promiseTimeout_1 = require("./promiseTimeout");
 const confirmationStatusValues = {
     processed: 0,
     confirmed: 1,
@@ -16,7 +20,75 @@ class TransactionConfirmationManager {
         this.intervalId = null;
         this.connection = connection;
     }
-    async confirmTransaction(txSig, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment, timeout = 30000, pollInterval = 1000, searchTransactionHistory = false) {
+    async confirmTransactionWebSocket(txSig, timeout = 30000, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment) {
+        const start = Date.now();
+        const subscriptionCommitment = desiredConfirmationStatus || config_1.DEFAULT_CONFIRMATION_OPTS.commitment;
+        let response = null;
+        let subscriptionId;
+        const confirmationPromise = new Promise((resolve, reject) => {
+            try {
+                subscriptionId = this.connection.onSignature(txSig, (result, context) => {
+                    response = {
+                        context,
+                        value: result,
+                    };
+                    resolve(null);
+                }, subscriptionCommitment);
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        // We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+        const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+            txSig,
+        ]);
+        const resolveReference = {};
+        // This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+        const overallWaitingForConfirmationPromise = new Promise((resolve) => {
+            resolveReference.resolve = resolve;
+        });
+        // Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+        oneShotConfirmationPromise.then(async (oneShotResponse) => {
+            var _a, _b;
+            if (!oneShotResponse || !((_a = oneShotResponse === null || oneShotResponse === void 0 ? void 0 : oneShotResponse.value) === null || _a === void 0 ? void 0 : _a[0]))
+                return;
+            const resultValue = oneShotResponse.value[0];
+            if (resultValue.err) {
+                await (0, reportTransactionError_1.throwTransactionError)(txSig, this.connection);
+            }
+            if (this.checkStatusMatchesDesiredConfirmationStatus(resultValue, desiredConfirmationStatus)) {
+                response = {
+                    context: oneShotResponse.context,
+                    value: oneShotResponse.value[0],
+                };
+                (_b = resolveReference.resolve) === null || _b === void 0 ? void 0 : _b.call(resolveReference);
+            }
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        // Await for the websocket confirmation with the configured timeout
+        (0, promiseTimeout_1.promiseTimeout)(confirmationPromise, timeout).then(() => {
+            var _a;
+            (_a = resolveReference.resolve) === null || _a === void 0 ? void 0 : _a.call(resolveReference);
+        }, (onRejected) => {
+            throw onRejected;
+        });
+        try {
+            await overallWaitingForConfirmationPromise;
+        }
+        finally {
+            if (subscriptionId !== undefined) {
+                this.connection.removeSignatureListener(subscriptionId);
+            }
+        }
+        const duration = (Date.now() - start) / 1000;
+        if (response === null) {
+            throw new __1.TxSendError(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`, txConstants_1.NOT_CONFIRMED_ERROR_CODE);
+        }
+        return response;
+    }
+    async confirmTransactionPolling(txSig, desiredConfirmationStatus = config_1.DEFAULT_CONFIRMATION_OPTS.commitment, timeout = 30000, pollInterval = 1000, searchTransactionHistory = false) {
         // Interval must be > 400ms and a multiple of 100ms
         if (pollInterval < 400 || pollInterval % 100 !== 0) {
             throw new Error('Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms');
@@ -60,6 +132,14 @@ class TransactionConfirmationManager {
             this.intervalId = null;
         }
     }
+    checkStatusMatchesDesiredConfirmationStatus(status, desiredConfirmationStatus) {
+        if (status.confirmationStatus &&
+            confirmationStatusValues[status.confirmationStatus] >=
+                confirmationStatusValues[desiredConfirmationStatus]) {
+            return true;
+        }
+        return false;
+    }
     async checkTransactionStatuses(requests) {
         const txSigs = requests.map((request) => request.txSig);
         const { value: statuses } = await this.connection.getSignatureStatuses(txSigs, {
@@ -75,8 +155,8 @@ class TransactionConfirmationManager {
                 continue;
             }
             if (status.err) {
-                request.reject(new Error(`Transaction failed: ${JSON.stringify(status.err)}`));
                 this.pendingConfirmations.delete(request.txSig);
+                request.reject(await (0, reportTransactionError_1.getTransactionErrorFromTxSig)(request.txSig, this.connection));
                 continue;
             }
             if (confirmationStatusValues[status.confirmationStatus] === undefined ||
@@ -84,9 +164,7 @@ class TransactionConfirmationManager {
                     undefined) {
                 throw new Error(`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`);
             }
-            if (status.confirmationStatus &&
-                confirmationStatusValues[status.confirmationStatus] >=
-                    confirmationStatusValues[request.desiredConfirmationStatus]) {
+            if (this.checkStatusMatchesDesiredConfirmationStatus(status, request.desiredConfirmationStatus)) {
                 request.resolve(status);
                 this.pendingConfirmations.delete(request.txSig);
             }

package/package.json

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

package/src/config.ts

@@ -44,6 +44,8 @@ export const DRIFT_PROGRAM_ID = 'dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH';
 export const DRIFT_ORACLE_RECEIVER_ID =
 	'G6EoTTTgpkNBtVXo96EQp2m6uwwVh2Kt6YidjkmQqoha';
 export const SWIFT_ID = 'SW1fThqrxLzVprnCMpiybiqYQfoNCdduC5uWsSUKChS';
+export const ANCHOR_TEST_SWIFT_ID =
+	'DpaEdAPW3ZX67fnczT14AoX12Lx9VMkxvtT81nCHy3Nv';
 
 export const DEFAULT_CONFIRMATION_OPTS: ConfirmOptions = {
 	preflightCommitment: 'confirmed',

package/src/constants/perpMarkets.ts

@@ -297,7 +297,7 @@ export const DevnetPerpMarkets: PerpMarketConfig[] = [
 		symbol: 'W-PERP',
 		baseAssetSymbol: 'W',
 		marketIndex: 23,
-		oracle: new PublicKey('4iCi4DvXrubHQne8jzbMaWL3pd7v1Fip8iTe4H9vHNXB'),
+		oracle: new PublicKey('J9nrFWjDUeDVZ4BhhxsbQXWgLcLEgQyNBrCbwSADmJdr'),
 		launchTs: 1709852537000,
 		oracleSource: OracleSource.SWITCHBOARD_ON_DEMAND,
 		pythFeedId:

package/src/constants/txConstants.ts

@@ -0,0 +1 @@
+export const NOT_CONFIRMED_ERROR_CODE = -1001;

package/src/driftClient.ts

@@ -181,6 +181,7 @@ export class DriftClient {
 	connection: Connection;
 	wallet: IWallet;
 	public program: Program;
+	public swiftID: PublicKey;
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
 	users = new Map<string, User>();
@@ -245,6 +246,7 @@ export class DriftClient {
 			config.programID ?? new PublicKey(DRIFT_PROGRAM_ID),
 			this.provider
 		);
+		this.swiftID = config.swiftID ?? new PublicKey(SWIFT_ID);
 
 		this.authority = config.authority ?? this.wallet.publicKey;
 		this.activeSubAccountId = config.activeSubAccountId ?? 0;
@@ -5483,7 +5485,7 @@ export class DriftClient {
 
 		const swiftServerSignatureIx =
 			Ed25519Program.createInstructionWithPublicKey({
-				publicKey: new PublicKey(SWIFT_ID).toBytes(),
+				publicKey: new PublicKey(this.swiftID).toBytes(),
 				signature: Uint8Array.from(swiftSignature),
 				message: Uint8Array.from(encodedSwiftServerMessage),
 			});

package/src/driftClientConfig.ts

@@ -18,6 +18,7 @@ export type DriftClientConfig = {
 	wallet: IWallet;
 	env?: DriftEnv;
 	programID?: PublicKey;
+	swiftID?: PublicKey;
 	accountSubscription?: DriftClientSubscriptionConfig;
 	opts?: ConfirmOptions;
 	txSender?: TxSender;

package/src/tx/baseTxSender.ts

@@ -15,7 +15,6 @@ import {
 	TransactionSignature,
 	Connection,
 	VersionedTransaction,
-	SendTransactionError,
 	TransactionInstruction,
 	AddressLookupTableAccount,
 	BlockhashWithExpiryBlockHeight,
@@ -26,11 +25,12 @@ import { TxHandler } from './txHandler';
 import { IWallet } from '../types';
 import NodeCache from 'node-cache';
 import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
+import { throwTransactionError } from './reportTransactionError';
 
 const BASELINE_TX_LAND_RATE = 0.9;
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES = 10;
-const NOT_CONFIRMED_ERROR_CODE = -1001;
 
 export abstract class BaseTxSender implements TxSender {
 	connection: Connection;
@@ -406,40 +406,18 @@ export abstract class BaseTxSender implements TxSender {
 	public async checkConfirmationResultForError(
 		txSig: string,
 		result: SignatureResult
-	) {
+	): Promise<void> {
 		if (result.err) {
-			await this.reportTransactionError(txSig);
+			await throwTransactionError(
+				txSig,
+				this.connection,
+				this.opts?.commitment
+			);
 		}
 
 		return;
 	}
 
-	public async reportTransactionError(txSig: string) {
-		const transactionResult = await this.connection.getTransaction(txSig, {
-			maxSupportedTransactionVersion: 0,
-		});
-
-		if (!transactionResult?.meta?.err) {
-			return undefined;
-		}
-
-		const logs = transactionResult.meta.logMessages;
-
-		const lastLog = logs[logs.length - 1];
-
-		const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
-
-		// @ts-ignore
-		throw new SendTransactionError({
-			action: 'send',
-			signature: txSig,
-			transactionMessage: `Transaction Failed${
-				friendlyMessage ? `: ${friendlyMessage}` : ''
-			}`,
-			logs,
-		});
-	}
-
 	public getTxLandRate(): number {
 		if (!this.trackTxLandRate) {
 			console.warn(

package/src/tx/reportTransactionError.ts

@@ -0,0 +1,159 @@
+import {
+	Commitment,
+	Connection,
+	Finality,
+	SendTransactionError,
+	VersionedTransactionResponse,
+} from '@solana/web3.js';
+import { DEFAULT_CONFIRMATION_OPTS } from '../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: Commitment): Finality => {
+	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: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<VersionedTransactionResponse> => {
+	const finality = commitmentToFinality(
+		commitment || connection.commitment || DEFAULT_CONFIRMATION_OPTS.commitment
+	);
+	return await connection.getTransaction(txSig, {
+		maxSupportedTransactionVersion: 0,
+		commitment: finality,
+	});
+};
+
+const getTransactionResultWithRetry = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<VersionedTransactionResponse> => {
+	const start = Date.now();
+
+	const retryTimeout = 3_000; // 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
+ */
+export const throwTransactionError = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<void> => {
+	const err = await getTransactionErrorFromTxSig(txSig, connection, commitment);
+
+	if (err) {
+		throw err;
+	}
+
+	return;
+};
+
+/**
+ * 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 const getTransactionErrorFromTxSig = async (
+	txSig: string,
+	connection: Connection,
+	commitment?: Commitment
+): Promise<SendTransactionError> => {
+	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 SendTransactionError({
+			action: 'send',
+			signature: txSig,
+			transactionMessage: `Transaction Failed`,
+		});
+	}
+
+	if (!transactionResult?.meta?.err) {
+		// Assume that the transaction was successful and we are here erroneously because we have a result with no error
+		return;
+	}
+
+	return getTransactionError(transactionResult);
+};
+
+export const getTransactionError = (
+	transactionResult: VersionedTransactionResponse
+): SendTransactionError => {
+	if (!transactionResult?.meta?.err) {
+		return;
+	}
+
+	const logs = transactionResult?.meta?.logMessages ?? ['No logs'];
+
+	const lastLog = logs[logs.length - 1];
+
+	const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
+
+	return new SendTransactionError({
+		action: 'send',
+		signature: transactionResult?.transaction?.signatures?.[0],
+		transactionMessage: `Transaction Failed${
+			friendlyMessage ? `: ${friendlyMessage}` : ''
+		}`,
+		logs,
+	});
+};

package/src/tx/whileValidTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import {
 	ConfirmOptions,
 	Connection,
@@ -62,6 +62,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 		additionalTxSenderCallbacks = [],
 		txHandler,
 		trackTxLandRate,
@@ -74,6 +75,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		retrySleep?: number;
 		additionalConnections?;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+		confirmationStrategy: ConfirmationStrategy;
 		txHandler?: TxHandler;
 		trackTxLandRate?: boolean;
 		txLandRateLookbackWindowMinutes?: number;
@@ -88,6 +90,7 @@ export class WhileValidTxSender extends BaseTxSender {
 			txHandler,
 			trackTxLandRate,
 			txLandRateLookbackWindowMinutes,
+			confirmationStrategy,
 			landRateToFeeFunc,
 		});
 		this.retrySleep = retrySleep;
@@ -187,11 +190,6 @@ export class WhileValidTxSender extends BaseTxSender {
 		const txSig = bs58.encode(signedTx.signatures[0]);
 		this.untilValid.set(txSig, latestBlockhash);
 
-		console.debug(
-			`preflight_commitment`,
-			`sending_tx_with_preflight_commitment::${opts?.preflightCommitment}`
-		);
-
 		return this.sendRawTransaction(signedTx.serialize(), opts);
 	}
 
@@ -201,10 +199,6 @@ export class WhileValidTxSender extends BaseTxSender {
 	): Promise<TxSigAndSlot> {
 		const startTime = this.getTimestamp();
 
-		console.debug(
-			`preflight_commitment`,
-			`sending_tx_with_preflight_commitment::${opts?.preflightCommitment}`
-		);
 		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
 		this.txSigCache?.set(txid, false);
 		this.sendToAdditionalConnections(rawTransaction, opts);

package/src/types.ts

@@ -1064,6 +1064,7 @@ export type SwiftServerMessage = {
 export type SwiftOrderParamsMessage = {
 	swiftOrderParams: OptionalOrderParams;
 	expectedOrderId: number;
+	subAccountId: number;
 	takeProfitOrderParams: SwiftTriggerOrderParams | null;
 	stopLossOrderParams: SwiftTriggerOrderParams | null;
 };

package/src/util/TransactionConfirmationManager.ts

@@ -1,9 +1,24 @@
 import {
+	ClientSubscriptionId,
 	Connection,
+	Context,
+	RpcResponseAndContext,
+	SignatureResult,
 	SignatureStatus,
 	TransactionConfirmationStatus,
 } from '@solana/web3.js';
 import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+import { TxSendError } from '..';
+import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
+import {
+	getTransactionErrorFromTxSig,
+	throwTransactionError,
+} from '../tx/reportTransactionError';
+import { promiseTimeout } from './promiseTimeout';
+
+type ResolveReference = {
+	resolve?: () => void;
+};
 
 const confirmationStatusValues: Record<TransactionConfirmationStatus, number> =
 	{
@@ -36,7 +51,113 @@ export class TransactionConfirmationManager {
 		this.connection = connection;
 	}
 
-	async confirmTransaction(
+	async confirmTransactionWebSocket(
+		txSig: string,
+		timeout = 30000,
+		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		const start = Date.now();
+		const subscriptionCommitment =
+			desiredConfirmationStatus || DEFAULT_CONFIRMATION_OPTS.commitment;
+
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+
+		let subscriptionId: ClientSubscriptionId;
+
+		const confirmationPromise = new Promise((resolve, reject) => {
+			try {
+				subscriptionId = this.connection.onSignature(
+					txSig,
+					(result: SignatureResult, context: Context) => {
+						response = {
+							context,
+							value: result,
+						};
+						resolve(null);
+					},
+					subscriptionCommitment
+				);
+			} catch (err) {
+				reject(err);
+			}
+		});
+
+		// We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+		const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+			txSig,
+		]);
+
+		const resolveReference: ResolveReference = {};
+
+		// This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+		const overallWaitingForConfirmationPromise = new Promise<void>(
+			(resolve) => {
+				resolveReference.resolve = resolve;
+			}
+		);
+
+		// Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+		oneShotConfirmationPromise.then(
+			async (oneShotResponse) => {
+				if (!oneShotResponse || !oneShotResponse?.value?.[0]) return;
+
+				const resultValue = oneShotResponse.value[0];
+
+				if (resultValue.err) {
+					await throwTransactionError(txSig, this.connection);
+				}
+
+				if (
+					this.checkStatusMatchesDesiredConfirmationStatus(
+						resultValue,
+						desiredConfirmationStatus
+					)
+				) {
+					response = {
+						context: oneShotResponse.context,
+						value: oneShotResponse.value[0],
+					};
+					resolveReference.resolve?.();
+				}
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		// Await for the websocket confirmation with the configured timeout
+		promiseTimeout(confirmationPromise, timeout).then(
+			() => {
+				resolveReference.resolve?.();
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		try {
+			await overallWaitingForConfirmationPromise;
+		} finally {
+			if (subscriptionId !== undefined) {
+				this.connection.removeSignatureListener(subscriptionId);
+			}
+		}
+
+		const duration = (Date.now() - start) / 1000;
+
+		if (response === null) {
+			throw new TxSendError(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
+			);
+		}
+
+		return response;
+	}
+
+	async confirmTransactionPolling(
 		txSig: string,
 		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus,
 		timeout = 30000,
@@ -99,6 +220,21 @@ export class TransactionConfirmationManager {
 		}
 	}
 
+	private checkStatusMatchesDesiredConfirmationStatus(
+		status: SignatureStatus,
+		desiredConfirmationStatus: TransactionConfirmationStatus
+	): boolean {
+		if (
+			status.confirmationStatus &&
+			confirmationStatusValues[status.confirmationStatus] >=
+				confirmationStatusValues[desiredConfirmationStatus]
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
 	private async checkTransactionStatuses(
 		requests: TransactionConfirmationRequest[]
 	) {
@@ -125,10 +261,10 @@ export class TransactionConfirmationManager {
 			}
 
 			if (status.err) {
+				this.pendingConfirmations.delete(request.txSig);
 				request.reject(
-					new Error(`Transaction failed: ${JSON.stringify(status.err)}`)
+					await getTransactionErrorFromTxSig(request.txSig, this.connection)
 				);
-				this.pendingConfirmations.delete(request.txSig);
 				continue;
 			}
 
@@ -143,9 +279,10 @@ export class TransactionConfirmationManager {
 			}
 
 			if (
-				status.confirmationStatus &&
-				confirmationStatusValues[status.confirmationStatus] >=
-					confirmationStatusValues[request.desiredConfirmationStatus]
+				this.checkStatusMatchesDesiredConfirmationStatus(
+					status,
+					request.desiredConfirmationStatus
+				)
 			) {
 				request.resolve(status);
 				this.pendingConfirmations.delete(request.txSig);

package/tests/tx/TransactionConfirmationManager.test.ts

@@ -1,10 +1,14 @@
 import { expect } from 'chai';
 import sinon from 'sinon';
-import { Connection, SignatureStatus } from '@solana/web3.js';
+import {
+	Connection,
+	SignatureStatus,
+	VersionedTransactionResponse,
+} from '@solana/web3.js';
 import { TransactionConfirmationManager } from '../../src/util/TransactionConfirmationManager';
 import assert from 'assert';
 
-describe('TransactionConfirmationManager', () => {
+describe('TransactionConfirmationManager_Polling_Tests', () => {
 	let manager: TransactionConfirmationManager;
 	let mockConnection: sinon.SinonStubbedInstance<Connection>;
 
@@ -21,7 +25,12 @@ describe('TransactionConfirmationManager', () => {
 
 	it('should throw error for invalid poll interval', async () => {
 		try {
-			await manager.confirmTransaction('fakeTxSig', 'confirmed', 30000, 300);
+			await manager.confirmTransactionPolling(
+				'fakeTxSig',
+				'confirmed',
+				30000,
+				300
+			);
 			assert.fail('Expected an error to be thrown');
 		} catch (error) {
 			assert(error instanceof Error);
@@ -46,7 +55,7 @@ describe('TransactionConfirmationManager', () => {
 			value: [fakeStatus],
 		});
 
-		const result = await manager.confirmTransaction(
+		const result = await manager.confirmTransactionPolling(
 			fakeTxSig,
 			'confirmed',
 			30000,
@@ -61,7 +70,7 @@ describe('TransactionConfirmationManager', () => {
 		).to.be.true;
 	});
 
-	it('should reject when transaction fails', async () => {
+	it('should reject when transaction fails', async function () {
 		const fakeTxSig = 'fakeTxSig';
 		const fakeStatus: SignatureStatus = {
 			slot: 100,
@@ -75,15 +84,25 @@ describe('TransactionConfirmationManager', () => {
 			value: [fakeStatus],
 		});
 
+		// The transaction manager falls into getTransaction when it detects a transaction failure so we need to mock that as well
+		// @ts-ignore
+		mockConnection.getTransaction.resolves({
+			meta: {
+				logMessages: ['Transaction failed: Custom'],
+				err: { InstructionError: [0, 'Custom'] },
+			},
+		} as VersionedTransactionResponse);
+
 		try {
-			await manager.confirmTransaction(fakeTxSig, 'confirmed', 30000, 400);
+			await manager.confirmTransactionPolling(
+				fakeTxSig,
+				'confirmed',
+				30000,
+				400
+			);
 			assert.fail('Expected an error to be thrown');
 		} catch (error) {
-			assert(error instanceof Error);
-			assert.strictEqual(
-				error.message,
-				'Transaction failed: {"InstructionError":[0,"Custom"]}'
-			);
+			return;
 		}
 	});
 
@@ -96,7 +115,7 @@ describe('TransactionConfirmationManager', () => {
 			value: [null],
 		});
 
-		const promise = manager.confirmTransaction(
+		const promise = manager.confirmTransactionPolling(
 			fakeTxSig,
 			'confirmed',
 			5000,
@@ -140,13 +159,13 @@ describe('TransactionConfirmationManager', () => {
 			value: [fakeStatus1, fakeStatus2],
 		});
 
-		const promise1 = manager.confirmTransaction(
+		const promise1 = manager.confirmTransactionPolling(
 			fakeTxSig1,
 			'confirmed',
 			30000,
 			400
 		);
-		const promise2 = manager.confirmTransaction(
+		const promise2 = manager.confirmTransactionPolling(
 			fakeTxSig2,
 			'confirmed',
 			30000,
@@ -206,13 +225,13 @@ describe('TransactionConfirmationManager', () => {
 		const startTime = Date.now();
 
 		// Start both confirmation processes
-		const promise1 = manager.confirmTransaction(
+		const promise1 = manager.confirmTransactionPolling(
 			fakeTxSig1,
 			'confirmed',
 			5000,
 			400
 		);
-		const promise2 = manager.confirmTransaction(
+		const promise2 = manager.confirmTransactionPolling(
 			fakeTxSig2,
 			'confirmed',
 			5000,