@drift-labs/sdk 2.84.0-beta.4 → 2.84.0-beta.6

package/VERSION

@@ -1 +1 @@
-2.84.0-beta.4
+2.84.0-beta.6

package/lib/constants/spotMarkets.js

@@ -228,6 +228,16 @@ exports.MainnetSpotMarkets = [
         precisionExp: numericConstants_1.NINE,
         launchTs: 1716595200000,
     },
+    {
+        symbol: 'USDY',
+        marketIndex: 18,
+        oracle: new web3_js_1.PublicKey('DiqUGbq5CV8Tjcae1whjrX97qPo6gU7BKAvKNFc2vrX8'),
+        oracleSource: __1.OracleSource.SWITCHBOARD,
+        mint: new web3_js_1.PublicKey('A1KLoBrKBde8Ty9qtNQUtq3C2ortoC3u7twggz7sEto6'),
+        precision: new __1.BN(10).pow(numericConstants_1.SIX),
+        precisionExp: numericConstants_1.SIX,
+        launchTs: 1718811089000,
+    },
 ];
 exports.SpotMarkets = {
     devnet: exports.DevnetSpotMarkets,

package/lib/dlob/orderBookLevels.js

@@ -92,7 +92,10 @@ function getVammL2Generator({ marketAccount, oraclePriceData, numOrders, now, to
         (0, assert_1.assert)(topOfBookQuoteAmounts.length < numOrders);
     }
     const updatedAmm = (0, __1.calculateUpdatedAMM)(marketAccount.amm, oraclePriceData);
-    let [openBids, openAsks] = (0, __1.calculateMarketOpenBidAsk)(updatedAmm.baseAssetReserve, updatedAmm.minBaseAssetReserve, updatedAmm.maxBaseAssetReserve, updatedAmm.orderStepSize);
+    const vammFillsDisabled = (0, __1.isOperationPaused)(marketAccount.pausedOperations, __1.PerpOperation.AMM_FILL);
+    let [openBids, openAsks] = vammFillsDisabled
+        ? [__1.ZERO, __1.ZERO]
+        : (0, __1.calculateMarketOpenBidAsk)(updatedAmm.baseAssetReserve, updatedAmm.minBaseAssetReserve, updatedAmm.maxBaseAssetReserve, updatedAmm.orderStepSize);
     const minOrderSize = marketAccount.amm.minOrderSize;
     if (openBids.lt(minOrderSize.muln(2))) {
         openBids = __1.ZERO;

package/lib/driftClient.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="bn.js" />
 import { AnchorProvider, BN, Program, ProgramAccount } from '@coral-xyz/anchor';
-import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly, SettlePnlMode } from './types';
+import { StateAccount, IWallet, PositionDirection, UserAccount, PerpMarketAccount, OrderParams, Order, SpotMarketAccount, SpotPosition, MakerInfo, TakerInfo, OptionalOrderParams, ReferrerInfo, MarketType, TxParams, SerumV3FulfillmentConfigAccount, ReferrerNameAccount, OrderTriggerCondition, PerpMarketExtendedInfo, UserStatsAccount, PhoenixV1FulfillmentConfigAccount, ModifyOrderPolicy, SwapReduceOnly, SettlePnlMode, SignedTxData, MappedRecord } from './types';
 import * as anchor from '@coral-xyz/anchor';
 import { Connection, PublicKey, TransactionSignature, ConfirmOptions, Transaction, TransactionInstruction, AccountMeta, Signer, AddressLookupTableAccount, TransactionVersion, VersionedTransaction, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
 import { TokenFaucet } from './tokenFaucet';
@@ -292,6 +292,12 @@ export declare class DriftClient {
      */
     openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
     sendSignedTx(tx: Transaction, opts?: ConfirmOptions): Promise<TransactionSignature>;
+    prepareMarketOrderTxs(orderParams: OptionalOrderParams, userAccountPublicKey: PublicKey, userAccount: UserAccount, makerInfo?: MakerInfo | MakerInfo[], txParams?: TxParams, bracketOrdersParams?: OptionalOrderParams[], referrerInfo?: ReferrerInfo, cancelExistingOrders?: boolean, settlePnl?: boolean): Promise<{
+        cancelExistingOrdersTx?: Transaction | VersionedTransaction;
+        settlePnlTx?: Transaction | VersionedTransaction;
+        fillTx?: Transaction | VersionedTransaction;
+        marketOrderTx: Transaction | VersionedTransaction;
+    }>;
     /**
      * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
      * @param orderParams
@@ -330,11 +336,17 @@ export declare class DriftClient {
         direction?: PositionDirection;
     }, placeOrderParams: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    preparePlaceOrdersTx(params: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<{
+        placeOrdersTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
+    }>;
     getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
     fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, fillerPublicKey?: number): Promise<TransactionSignature>;
     getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerSubAccountId?: number): Promise<TransactionInstruction>;
     getRevertFillIx(fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeSpotOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    preparePlaceSpotOrderTx(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<{
+        placeSpotOrderTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
+    }>;
     getPlaceSpotOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
     fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
     getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
@@ -447,6 +459,11 @@ export declare class DriftClient {
     updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
     getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean): Promise<{
+        placeAndTakeTx: Transaction | VersionedTransaction;
+        cancelExistingOrdersTx: Transaction | VersionedTransaction;
+        settlePnlTx: Transaction | VersionedTransaction;
+    }>;
     placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean): Promise<{
         txSig: TransactionSignature;
         signedCancelExistingOrdersTx?: Transaction;
@@ -455,6 +472,9 @@ export declare class DriftClient {
     getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
+    preparePlaceAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<{
+        placeAndTakeSpotOrderTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
+    }>;
     placeAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getPlaceAndTakeSpotOrderIx(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     placeAndMakeSpotOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
@@ -687,8 +707,13 @@ export declare class DriftClient {
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
     buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<Transaction | VersionedTransaction>;
     buildBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<(Transaction | VersionedTransaction)[]>;
-    buildAndSignBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], keys: string[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<{
-        [key: string]: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
+    buildTransactionsMap(instructionsMap: Record<string, TransactionInstruction | TransactionInstruction[]>, txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<MappedRecord<Record<string, anchor.web3.TransactionInstruction | anchor.web3.TransactionInstruction[]>, anchor.web3.Transaction | anchor.web3.VersionedTransaction>>;
+    buildAndSignTransactionsMap(instructionsMap: Record<string, TransactionInstruction | TransactionInstruction[]>, txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<{
+        signedTxMap: Record<string, anchor.web3.Transaction>;
+        signedTxData: SignedTxData[];
+    } | {
+        signedTxMap: MappedRecord<Record<string, anchor.web3.TransactionInstruction | anchor.web3.TransactionInstruction[]>, anchor.web3.Transaction | anchor.web3.VersionedTransaction>;
+        signedTxData: SignedTxData[];
     }>;
 }
 export {};

package/lib/driftClient.js

@@ -1510,6 +1510,40 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, undefined, opts !== null && opts !== void 0 ? opts : this.opts, true);
         return txSig;
     }
+    async prepareMarketOrderTxs(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl) {
+        const marketIndex = orderParams.marketIndex;
+        const orderId = userAccount.nextOrderId;
+        const ixPromisesForTxs = {
+            cancelExistingOrdersTx: undefined,
+            settlePnlTx: undefined,
+            fillTx: undefined,
+            marketOrderTx: undefined,
+        };
+        const txKeys = Object.keys(ixPromisesForTxs);
+        ixPromisesForTxs.marketOrderTx = this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
+        /* Cancel open orders in market if requested */
+        if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            ixPromisesForTxs.cancelExistingOrdersTx = this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId);
+        }
+        /* Settle PnL after fill if requested */
+        if (settlePnl && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
+            ixPromisesForTxs.settlePnlTx = this.settlePNLIx(userAccountPublicKey, userAccount, marketIndex);
+        }
+        // use versioned transactions if there is a lookup table account and wallet is compatible
+        if (this.txVersion === 0) {
+            ixPromisesForTxs.fillTx = this.getFillPerpOrderIx(userAccountPublicKey, userAccount, {
+                orderId,
+                marketIndex,
+            }, makerInfo, referrerInfo, userAccount.subAccountId);
+        }
+        const ixs = await Promise.all(Object.values(ixPromisesForTxs));
+        const ixsMap = ixs.reduce((acc, ix, i) => {
+            acc[txKeys[i]] = ix;
+            return acc;
+        }, {});
+        const txsMap = (await this.buildTransactionsMap(ixsMap, txParams));
+        return txsMap;
+    }
     /**
      * Sends a market order and returns a signed tx which can fill the order against the vamm, which the caller can use to fill their own order if required.
      * @param orderParams
@@ -1522,53 +1556,15 @@ class DriftClient {
      * @returns
      */
     async sendMarketOrderAndGetSignedFillTx(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams = new Array(), referrerInfo, cancelExistingOrders, settlePnl) {
-        const marketIndex = orderParams.marketIndex;
-        const orderId = userAccount.nextOrderId;
-        const ordersIx = await this.getPlaceOrdersIx([orderParams, ...bracketOrdersParams], userAccount.subAccountId);
-        const ixsToSign = [];
-        const keys = {
-            signedCancelExistingOrdersTx: 'signedCancelExistingOrdersTx',
-            signedSettlePnlTx: 'signedSettlePnlTx',
-            signedFillTx: 'signedFillTx',
-            signedMarketOrderTx: 'signedMarketOrderTx',
-        };
-        /* Cancel open orders in market if requested */
-        if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
-            ixsToSign.push({
-                key: keys.signedCancelExistingOrdersTx,
-                ix: await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, userAccount.subAccountId),
-            });
-        }
-        /* Settle PnL after fill if requested */
-        if (settlePnl && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
-            ixsToSign.push({
-                key: keys.signedSettlePnlTx,
-                ix: await this.settlePNLIx(userAccountPublicKey, userAccount, marketIndex),
-            });
-        }
-        // use versioned transactions if there is a lookup table account and wallet is compatible
-        if (this.txVersion === 0) {
-            ixsToSign.push({
-                key: keys.signedFillTx,
-                ix: await this.getFillPerpOrderIx(userAccountPublicKey, userAccount, {
-                    orderId,
-                    marketIndex,
-                }, makerInfo, referrerInfo, userAccount.subAccountId),
-            });
-        }
-        // Apply the latest blockhash to the txs so that we can sign before sending them
-        ixsToSign.push({
-            key: keys.signedMarketOrderTx,
-            ix: ordersIx,
-        });
-        const signedTransactions = await this.buildAndSignBulkTransactions(ixsToSign.map((ix) => ix.ix), ixsToSign.map((ix) => ix.key), txParams);
-        const { txSig, slot } = await this.sendTransaction(signedTransactions[keys.signedMarketOrderTx], [], this.opts, true);
+        const preppedTxs = await this.prepareMarketOrderTxs(orderParams, userAccountPublicKey, userAccount, makerInfo, txParams, bracketOrdersParams, referrerInfo, cancelExistingOrders, settlePnl);
+        const signedTxs = (await this.txHandler.getSignedTransactionMap(preppedTxs, this.wallet)).signedTxMap;
+        const { txSig, slot } = await this.sendTransaction(signedTxs.marketOrderTx, [], this.opts, true);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return {
             txSig,
-            signedFillTx: signedTransactions === null || signedTransactions === void 0 ? void 0 : signedTransactions[keys.signedFillTx],
-            signedCancelExistingOrdersTx: signedTransactions === null || signedTransactions === void 0 ? void 0 : signedTransactions[keys.signedCancelExistingOrdersTx],
-            signedSettlePnlTx: signedTransactions === null || signedTransactions === void 0 ? void 0 : signedTransactions[keys.signedSettlePnlTx],
+            signedFillTx: signedTxs.fillTx,
+            signedCancelExistingOrdersTx: signedTxs.cancelExistingOrdersTx,
+            signedSettlePnlTx: signedTxs.settlePnlTx,
         };
     }
     async placePerpOrder(orderParams, txParams, subAccountId) {
@@ -1780,9 +1776,16 @@ class DriftClient {
         return txSig;
     }
     async placeOrders(params, txParams, subAccountId) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams), [], this.opts);
+        const { txSig } = await this.sendTransaction((await this.preparePlaceOrdersTx(params, txParams, subAccountId))
+            .placeOrdersTx, [], this.opts, false);
         return txSig;
     }
+    async preparePlaceOrdersTx(params, txParams, subAccountId) {
+        const tx = await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams);
+        return {
+            placeOrdersTx: tx,
+        };
+    }
     async getPlaceOrdersIx(params, subAccountId) {
         const user = await this.getUserAccountPublicKey(subAccountId);
         const readablePerpMarketIndex = [];
@@ -1893,11 +1896,18 @@ class DriftClient {
         });
     }
     async placeSpotOrder(orderParams, txParams, subAccountId) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceSpotOrderIx(orderParams, subAccountId), txParams), [], this.opts);
+        const { txSig, slot } = await this.sendTransaction((await this.preparePlaceSpotOrderTx(orderParams, txParams, subAccountId))
+            .placeSpotOrderTx, [], this.opts, false);
         this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
         this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
     }
+    async preparePlaceSpotOrderTx(orderParams, txParams, subAccountId) {
+        const tx = await this.buildTransaction(await this.getPlaceSpotOrderIx(orderParams, subAccountId), txParams);
+        return {
+            placeSpotOrderTx: tx,
+        };
+    }
     async getPlaceSpotOrderIx(orderParams, subAccountId) {
         orderParams = (0, orderParams_1.getOrderParams)(orderParams, { marketType: types_1.MarketType.SPOT });
         const userAccountPublicKey = await this.getUserAccountPublicKey(subAccountId);
@@ -2500,13 +2510,12 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails) {
+    async preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails) {
         const placeAndTakeIxs = [];
-        const txsToSign = [];
-        const keys = {
-            placeAndTakeIx: 'placeAndTakeIx',
-            cancelExistingOrdersTx: 'cancelExistingOrdersTx',
-            settlePnlTx: 'settlePnlTx',
+        const txsToSign = {
+            placeAndTakeTx: undefined,
+            cancelExistingOrdersTx: undefined,
+            settlePnlTx: undefined,
         };
         // Get recent block hash so that we can re-use it for all transactions. Makes this logic run faster with fewer RPC requests
         const recentBlockHash = await this.txHandler.getLatestBlockhashForTransaction();
@@ -2532,29 +2541,20 @@ class DriftClient {
                     earlyExitFailedPlaceAndTakeSim = true;
                     return;
                 }
-                txsToSign.push({
-                    key: keys.placeAndTakeIx,
-                    tx: await this.buildTransaction(placeAndTakeIxs, {
-                        ...txParamsWithoutImplicitSimulation,
-                        computeUnits: simulationResult.computeUnits,
-                    }, undefined, undefined, undefined, recentBlockHash),
-                });
+                txsToSign.placeAndTakeTx = await this.buildTransaction(placeAndTakeIxs, {
+                    ...txParamsWithoutImplicitSimulation,
+                    computeUnits: simulationResult.computeUnits,
+                }, undefined, undefined, undefined, recentBlockHash);
             }
             else {
-                txsToSign.push({
-                    key: keys.placeAndTakeIx,
-                    tx: await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, undefined, recentBlockHash),
-                });
+                txsToSign.placeAndTakeTx = await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, undefined, recentBlockHash);
             }
             return;
         };
         const prepCancelOrderTx = async () => {
             if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
                 const cancelOrdersIx = await this.getCancelOrdersIx(orderParams.marketType, orderParams.marketIndex, null, subAccountId);
-                txsToSign.push({
-                    key: keys.cancelExistingOrdersTx,
-                    tx: await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion, undefined, undefined, recentBlockHash),
-                });
+                txsToSign.cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion, undefined, undefined, recentBlockHash);
             }
             return;
         };
@@ -2562,10 +2562,7 @@ class DriftClient {
             if (settlePnl && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
                 const userAccountPublicKey = await this.getUserAccountPublicKey(subAccountId);
                 const settlePnlIx = await this.settlePNLIx(userAccountPublicKey, this.getUserAccount(subAccountId), orderParams.marketIndex);
-                txsToSign.push({
-                    key: keys.settlePnlTx,
-                    tx: await this.buildTransaction([settlePnlIx], txParams, this.txVersion, undefined, undefined, recentBlockHash),
-                });
+                txsToSign.settlePnlTx = await this.buildTransaction([settlePnlIx], txParams, this.txVersion, undefined, undefined, recentBlockHash);
             }
             return;
         };
@@ -2577,13 +2574,17 @@ class DriftClient {
         if (earlyExitFailedPlaceAndTakeSim) {
             return null;
         }
-        const signedTxs = await this.txHandler.getSignedTransactionMap(txsToSign.map((tx) => tx.tx), txsToSign.map((tx) => tx.key), this.provider.wallet);
-        const { txSig, slot } = await this.sendTransaction(signedTxs[keys.placeAndTakeIx], [], this.opts, true);
+        return txsToSign;
+    }
+    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails) {
+        const txsToSign = await this.preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams, txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails);
+        const signedTxs = (await this.txHandler.getSignedTransactionMap(txsToSign, this.provider.wallet)).signedTxMap;
+        const { txSig, slot } = await this.sendTransaction(signedTxs.placeAndTakeTx, [], this.opts, true);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return {
             txSig,
-            signedCancelExistingOrdersTx: signedTxs[keys.cancelExistingOrdersTx],
-            signedSettlePnlTx: signedTxs[keys.settlePnlTx],
+            signedCancelExistingOrdersTx: signedTxs.cancelExistingOrdersTx,
+            signedSettlePnlTx: signedTxs.settlePnlTx,
         };
     }
     async getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId) {
@@ -2684,8 +2685,14 @@ class DriftClient {
             remainingAccounts,
         });
     }
+    async preparePlaceAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams, subAccountId) {
+        const tx = await this.buildTransaction(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo, subAccountId), txParams);
+        return {
+            placeAndTakeSpotOrderTx: tx,
+        };
+    }
     async placeAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams, subAccountId) {
-        const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getPlaceAndTakeSpotOrderIx(orderParams, fulfillmentConfig, makerInfo, referrerInfo, subAccountId), txParams), [], this.opts);
+        const { txSig, slot } = await this.sendTransaction((await this.preparePlaceAndTakeSpotOrder(orderParams, fulfillmentConfig, makerInfo, referrerInfo, txParams, subAccountId)).placeAndTakeSpotOrderTx, [], this.opts, false);
         this.spotMarketLastSlotCache.set(orderParams.marketIndex, slot);
         this.spotMarketLastSlotCache.set(numericConstants_1.QUOTE_SPOT_MARKET_INDEX, slot);
         return txSig;
@@ -2876,9 +2883,9 @@ class DriftClient {
             oraclePriceOffset: newOraclePriceOffset || null,
             triggerPrice: newTriggerPrice || null,
             triggerCondition: newTriggerCondition || null,
-            auctionDuration: auctionDuration || 0,
-            auctionStartPrice: auctionStartPrice || numericConstants_1.ZERO,
-            auctionEndPrice: auctionEndPrice || numericConstants_1.ZERO,
+            auctionDuration: auctionDuration || null,
+            auctionStartPrice: auctionStartPrice || null,
+            auctionEndPrice: auctionEndPrice || null,
             reduceOnly: reduceOnly != undefined ? reduceOnly : null,
             postOnly: postOnly != undefined ? postOnly : null,
             immediateOrCancel: immediateOrCancel != undefined ? immediateOrCancel : null,
@@ -3658,9 +3665,21 @@ class DriftClient {
             forceVersionedTransaction,
         });
     }
-    async buildAndSignBulkTransactions(instructions, keys, txParams, txVersion, lookupTables, forceVersionedTransaction) {
+    async buildTransactionsMap(instructionsMap, txParams, txVersion, lookupTables, forceVersionedTransaction) {
+        return this.txHandler.buildTransactionsMap({
+            instructionsMap,
+            txVersion: txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion,
+            txParams: txParams !== null && txParams !== void 0 ? txParams : this.txParams,
+            connection: this.connection,
+            preFlightCommitment: this.opts.preflightCommitment,
+            fetchMarketLookupTableAccount: this.fetchMarketLookupTableAccount.bind(this),
+            lookupTables,
+            forceVersionedTransaction,
+        });
+    }
+    async buildAndSignTransactionsMap(instructionsMap, txParams, txVersion, lookupTables, forceVersionedTransaction) {
         return this.txHandler.buildAndSignTransactionMap({
-            instructions,
+            instructionsMap,
             txVersion: txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion,
             txParams: txParams !== null && txParams !== void 0 ? txParams : this.txParams,
             connection: this.connection,
@@ -3668,7 +3687,6 @@ class DriftClient {
             fetchMarketLookupTableAccount: this.fetchMarketLookupTableAccount.bind(this),
             lookupTables,
             forceVersionedTransaction,
-            keys,
         });
     }
 }

package/lib/factory/oracleClient.js

@@ -8,19 +8,32 @@ const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
 const anchor_1 = require("@coral-xyz/anchor");
 const prelaunchOracleClient_1 = require("../oracles/prelaunchOracleClient");
 const switchboardClient_1 = require("../oracles/switchboardClient");
+const pythPullClient_1 = require("../oracles/pythPullClient");
 function getOracleClient(oracleSource, connection, program) {
     if ((0, types_1.isVariant)(oracleSource, 'pyth')) {
         return new pythClient_1.PythClient(connection);
     }
+    if ((0, types_1.isVariant)(oracleSource, 'pythPull')) {
+        return new pythPullClient_1.PythPullClient(connection);
+    }
     if ((0, types_1.isVariant)(oracleSource, 'pyth1K')) {
         return new pythClient_1.PythClient(connection, new anchor_1.BN(1000));
     }
+    if ((0, types_1.isVariant)(oracleSource, 'pyth1KPull')) {
+        return new pythPullClient_1.PythPullClient(connection, new anchor_1.BN(1000));
+    }
     if ((0, types_1.isVariant)(oracleSource, 'pyth1M')) {
         return new pythClient_1.PythClient(connection, new anchor_1.BN(1000000));
     }
+    if ((0, types_1.isVariant)(oracleSource, 'pyth1MPull')) {
+        return new pythPullClient_1.PythPullClient(connection, new anchor_1.BN(1000000));
+    }
     if ((0, types_1.isVariant)(oracleSource, 'pythStableCoin')) {
         return new pythClient_1.PythClient(connection, undefined, true);
     }
+    if ((0, types_1.isVariant)(oracleSource, 'pythStableCoinPull')) {
+        return new pythPullClient_1.PythPullClient(connection, undefined, true);
+    }
     if ((0, types_1.isVariant)(oracleSource, 'switchboard')) {
         return new switchboardClient_1.SwitchboardClient(connection);
     }

package/lib/idl/drift.json

@@ -9254,6 +9254,18 @@
                     },
                     {
                         "name": "Prelaunch"
+                    },
+                    {
+                        "name": "PythPull"
+                    },
+                    {
+                        "name": "Pyth1KPull"
+                    },
+                    {
+                        "name": "Pyth1MPull"
+                    },
+                    {
+                        "name": "PythStableCoinPull"
                     }
                 ]
             }
@@ -11992,6 +12004,11 @@
             "code": 6266,
             "name": "OracleStaleForAMM",
             "msg": "OracleStaleForAMM"
+        },
+        {
+            "code": 6267,
+            "name": "UnableToParsePullOracleMessage",
+            "msg": "Unable to parse pull oracle message"
         }
     ]
 }

package/lib/oracles/pythPullClient.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { Connection, PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN, Program } from '@coral-xyz/anchor';
+import { PythSolanaReceiverProgram } from '@pythnetwork/pyth-solana-receiver';
+import { PriceUpdateAccount } from '@pythnetwork/pyth-solana-receiver/lib/PythSolanaReceiver';
+export declare class PythPullClient implements OracleClient {
+    private connection;
+    private multiple;
+    private stableCoin;
+    readonly receiver: Program<PythSolanaReceiverProgram>;
+    readonly decodeFunc: (name: string, data: Buffer) => PriceUpdateAccount;
+    constructor(connection: Connection, multiple?: BN, stableCoin?: boolean);
+    getOraclePriceData(pricePublicKey: PublicKey): Promise<OraclePriceData>;
+    getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
+}
+export declare function convertPythPrice(price: BN, exponent: number, multiple: BN): BN;

package/lib/oracles/pythPullClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPythPrice = exports.PythPullClient = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const pyth_solana_receiver_1 = require("@pythnetwork/pyth-solana-receiver");
+const __1 = require("..");
+class PythPullClient {
+    constructor(connection, multiple = numericConstants_1.ONE, stableCoin = false) {
+        this.connection = connection;
+        this.multiple = multiple;
+        this.stableCoin = stableCoin;
+        const provider = new anchor_1.AnchorProvider(this.connection, 
+        //@ts-ignore
+        new __1.Wallet(new web3_js_1.Keypair()), {
+            commitment: connection.commitment,
+        });
+        this.receiver = new anchor_1.Program(pyth_solana_receiver_1.pythSolanaReceiverIdl, pyth_solana_receiver_1.DEFAULT_RECEIVER_PROGRAM_ID, provider);
+        this.decodeFunc =
+            this.receiver.account.priceUpdateV2.coder.accounts.decodeUnchecked.bind(this.receiver.account.priceUpdateV2.coder.accounts);
+    }
+    async getOraclePriceData(pricePublicKey) {
+        const accountInfo = await this.connection.getAccountInfo(pricePublicKey);
+        return this.getOraclePriceDataFromBuffer(accountInfo.data);
+    }
+    getOraclePriceDataFromBuffer(buffer) {
+        const message = this.decodeFunc('priceUpdateV2', buffer);
+        const priceData = message.priceMessage;
+        const confidence = convertPythPrice(priceData.conf, priceData.exponent, this.multiple);
+        let price = convertPythPrice(priceData.price, priceData.exponent, this.multiple);
+        if (this.stableCoin) {
+            price = getStableCoinPrice(price, confidence);
+        }
+        return {
+            price,
+            slot: message.postedSlot,
+            confidence,
+            twap: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            twapConfidence: convertPythPrice(priceData.price, priceData.exponent, this.multiple),
+            hasSufficientNumberOfDataPoints: true,
+        };
+    }
+}
+exports.PythPullClient = PythPullClient;
+function convertPythPrice(price, exponent, multiple) {
+    exponent = Math.abs(exponent);
+    const pythPrecision = numericConstants_1.TEN.pow(new anchor_1.BN(exponent).abs()).div(multiple);
+    return price.mul(numericConstants_1.PRICE_PRECISION).div(pythPrecision);
+}
+exports.convertPythPrice = convertPythPrice;
+const fiveBPS = new anchor_1.BN(500);
+function getStableCoinPrice(price, confidence) {
+    if (price.sub(numericConstants_1.QUOTE_PRECISION).abs().lt(anchor_1.BN.min(confidence, fiveBPS))) {
+        return numericConstants_1.QUOTE_PRECISION;
+    }
+    else {
+        return price;
+    }
+}

package/lib/tx/txHandler.d.ts

@@ -1,5 +1,5 @@
 import { AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, Commitment, ConfirmOptions, Connection, Signer, Transaction, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
-import { DriftClientMetricsEvents, IWallet, TxParams } from '../types';
+import { DriftClientMetricsEvents, IWallet, MappedRecord, SignedTxData, TxParams } from '../types';
 export declare const COMPUTE_UNITS_DEFAULT = 200000;
 export type TxBuildingProps = {
     instructions: TransactionInstruction | TransactionInstruction[];
@@ -61,6 +61,7 @@ export declare class TxHandler {
      */
     prepareTx(tx: Transaction, additionalSigners: Array<Signer>, wallet?: IWallet, confirmationOpts?: ConfirmOptions, preSigned?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<Transaction>;
     private isVersionedTransaction;
+    private isLegacyTransaction;
     private getTxSigFromSignedTx;
     private getBlockhashFromSignedTx;
     private signTx;
@@ -75,7 +76,7 @@ export declare class TxHandler {
     private _generateVersionedTransaction;
     generateLegacyVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], wallet?: IWallet): VersionedTransaction;
     generateVersionedTransaction(recentBlockhash: BlockhashWithExpiryBlockHeight, ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], wallet?: IWallet): VersionedTransaction;
-    generateLegacyTransaction(ixs: TransactionInstruction[]): Transaction;
+    generateLegacyTransaction(ixs: TransactionInstruction[], recentBlockhash?: BlockhashWithExpiryBlockHeight): Transaction;
     /**
      * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
      * @param props
@@ -96,46 +97,48 @@ export declare class TxHandler {
     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.
+     * Get a map of signed and prepared transactions from an array of legacy 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;
+    getPreparedAndSignedLegacyTransactionMap<T extends Record<string, Transaction | undefined>>(txsMap: T, wallet?: IWallet, commitment?: Commitment, recentBlockhash?: BlockhashWithExpiryBlockHeight): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
     }>;
     /**
-     * Get a map of signed and prepared transactions from an array of legacy transactions
+     * Get a map of signed transactions from an array of transactions to sign.
      * @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;
+    getSignedTransactionMap<T extends Record<string, Transaction | VersionedTransaction | undefined>>(txsToSignMap: T, wallet?: IWallet): Promise<{
+        signedTxMap: T;
+        signedTxData: SignedTxData[];
     }>;
     /**
-     * Get a map of signed transactions from an array of transactions to sign.
-     * @param txsToSign
-     * @param keys
-     * @param wallet
+     * Accepts multiple instructions and builds a transaction for each. Prevents needing to spam RPC with requests for the same blockhash.
+     * @param props
      * @returns
      */
-    getSignedTransactionMap(txsToSign: (Transaction | VersionedTransaction | undefined)[], keys: string[], wallet?: IWallet): Promise<{
-        [key: string]: Transaction | VersionedTransaction | undefined;
-    }>;
+    buildTransactionsMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
+    }): Promise<MappedRecord<T, Transaction | VersionedTransaction>>;
     /**
      * Builds and signs transactions from a given array of instructions for multiple transactions.
      * @param props
      * @returns
      */
-    buildAndSignTransactionMap(props: Omit<TxBuildingProps, 'instructions'> & {
-        keys: string[];
-        instructions: (TransactionInstruction | TransactionInstruction[])[];
+    buildAndSignTransactionMap<T extends Record<string, TransactionInstruction | TransactionInstruction[]>>(props: Omit<TxBuildingProps, 'instructions'> & {
+        instructionsMap: T;
     }): Promise<{
-        [key: string]: Transaction | VersionedTransaction;
+        signedTxMap: Record<string, Transaction>;
+        signedTxData: SignedTxData[];
+    } | {
+        signedTxMap: MappedRecord<T, Transaction | VersionedTransaction>;
+        signedTxData: SignedTxData[];
     }>;
 }