@drift-labs/sdk 2.84.0-beta.5 → 2.84.0-beta.7

package/VERSION

@@ -1 +1 @@
-2.84.0-beta.5
+2.84.0-beta.7

package/lib/adminClient.d.ts

@@ -89,6 +89,8 @@ export declare class AdminClient extends DriftClient {
     getUpdateSpotMarketRevenueSettlePeriodIx(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionInstruction>;
     updateSpotMarketMaxTokenDeposits(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
     getUpdateSpotMarketMaxTokenDepositsIx(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionInstruction>;
+    updateSpotMarketMaxTokenBorrows(spotMarketIndex: number, maxTokenBorrows: BN): Promise<TransactionSignature>;
+    getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex: number, maxTokenBorrows: BN): Promise<TransactionInstruction>;
     updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionSignature>;
     getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionInstruction>;
     updateInsuranceFundUnstakingPeriod(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
@@ -125,8 +127,8 @@ export declare class AdminClient extends DriftClient {
     getUpdateDiscountMintIx(discountMint: PublicKey): Promise<TransactionInstruction>;
     updateSpotMarketMarginWeights(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionSignature>;
     getUpdateSpotMarketMarginWeightsIx(spotMarketIndex: number, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number): Promise<TransactionInstruction>;
-    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number): Promise<TransactionSignature>;
-    getUpdateSpotMarketBorrowRateIx(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number): Promise<TransactionInstruction>;
+    updateSpotMarketBorrowRate(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionSignature>;
+    getUpdateSpotMarketBorrowRateIx(spotMarketIndex: number, optimalUtilization: number, optimalBorrowRate: number, optimalMaxRate: number, minBorrowRate?: number | undefined): Promise<TransactionInstruction>;
     updateSpotMarketAssetTier(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionSignature>;
     getUpdateSpotMarketAssetTierIx(spotMarketIndex: number, assetTier: AssetTier): Promise<TransactionInstruction>;
     updateSpotMarketStatus(spotMarketIndex: number, marketStatus: MarketStatus): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -829,6 +829,23 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
+    async updateSpotMarketMaxTokenBorrows(spotMarketIndex, maxTokenBorrows) {
+        const updateSpotMarketMaxTokenBorrowsIx = await this.getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrows);
+        const tx = await this.buildTransaction(updateSpotMarketMaxTokenBorrowsIx);
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
+    async getUpdateSpotMarketMaxTokenBorrowsIx(spotMarketIndex, maxTokenBorrows) {
+        return this.program.instruction.updateSpotMarketMaxTokenBorrows(maxTokenBorrows, {
+            accounts: {
+                admin: this.isSubscribed
+                    ? this.getStateAccount().admin
+                    : this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+    }
     async updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex, scaleInitialAssetWeightStart) {
         const updateSpotMarketScaleInitialAssetWeightStartIx = await this.getUpdateSpotMarketScaleInitialAssetWeightStartIx(spotMarketIndex, scaleInitialAssetWeightStart);
         const tx = await this.buildTransaction(updateSpotMarketScaleInitialAssetWeightStartIx);
@@ -1150,14 +1167,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
-        const updateSpotMarketBorrowRateIx = await this.getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate);
+    async updateSpotMarketBorrowRate(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        const updateSpotMarketBorrowRateIx = await this.getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate);
         const tx = await this.buildTransaction(updateSpotMarketBorrowRateIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate) {
-        return await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, {
+    async getUpdateSpotMarketBorrowRateIx(spotMarketIndex, optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate) {
+        return await this.program.instruction.updateSpotMarketBorrowRate(optimalUtilization, optimalBorrowRate, optimalMaxRate, minBorrowRate, {
             accounts: {
                 admin: this.isSubscribed
                     ? this.getStateAccount().admin

package/lib/blockhashSubscriber/BlockhashSubscriber.d.ts

@@ -13,7 +13,13 @@ export declare class BlockhashSubscriber {
     getBlockhashCacheSize(): number;
     getLatestBlockHeight(): number;
     getLatestBlockHeightContext(): Context | undefined;
-    getLatestBlockhash(offset?: number): BlockhashWithExpiryBlockHeight | undefined;
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset?: number, offsetType?: 'index' | 'seconds'): BlockhashWithExpiryBlockHeight | undefined;
     pruneBlockhashes(): void;
     updateBlockhash(): Promise<void>;
     subscribe(): Promise<void>;

package/lib/blockhashSubscriber/BlockhashSubscriber.js

@@ -23,11 +23,20 @@ class BlockhashSubscriber {
     getLatestBlockHeightContext() {
         return this.latestBlockHeightContext;
     }
-    getLatestBlockhash(offset) {
+    /**
+     * Returns the latest cached blockhash, based on an offset from the latest obtained
+     * @param offset Offset to use, defaulting to 0
+     * @param offsetType If 'seconds', it will use calculate the actual element offset based on the update interval; otherwise it will return a fixed index
+     * @returns Cached blockhash at the given offset, or undefined
+     */
+    getLatestBlockhash(offset = 0, offsetType = 'index') {
         if (this.blockhashes.length === 0) {
             return undefined;
         }
-        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, offset !== null && offset !== void 0 ? offset : 0));
+        const elementOffset = offsetType == 'seconds'
+            ? Math.floor((offset * 1000) / this.updateIntervalMs)
+            : offset;
+        const clampedOffset = Math.max(0, Math.min(this.blockhashes.length - 1, elementOffset));
         return this.blockhashes[this.blockhashes.length - 1 - clampedOffset];
     }
     pruneBlockhashes() {

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/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';
@@ -99,7 +99,9 @@ export declare class DriftClient {
     getQuoteSpotMarketAccount(): SpotMarketAccount;
     getOraclePriceDataAndSlot(oraclePublicKey: PublicKey): DataAndSlot<OraclePriceData> | undefined;
     getSerumV3FulfillmentConfig(serumMarket: PublicKey): Promise<SerumV3FulfillmentConfigAccount>;
+    getSerumV3FulfillmentConfigs(): Promise<SerumV3FulfillmentConfigAccount[]>;
     getPhoenixV1FulfillmentConfig(phoenixMarket: PublicKey): Promise<PhoenixV1FulfillmentConfigAccount>;
+    getPhoenixV1FulfillmentConfigs(): Promise<PhoenixV1FulfillmentConfigAccount[]>;
     fetchMarketLookupTableAccount(): Promise<AddressLookupTableAccount>;
     /**
      * Update the wallet to use for drift transactions and linked user account
@@ -292,6 +294,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 +338,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 +461,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 +474,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 +709,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

@@ -304,10 +304,18 @@ class DriftClient {
         const address = await (0, pda_1.getSerumFulfillmentConfigPublicKey)(this.program.programId, serumMarket);
         return (await this.program.account.serumV3FulfillmentConfig.fetch(address));
     }
+    async getSerumV3FulfillmentConfigs() {
+        const accounts = await this.program.account.serumV3FulfillmentConfig.all();
+        return accounts.map((account) => account.account);
+    }
     async getPhoenixV1FulfillmentConfig(phoenixMarket) {
         const address = await (0, pda_1.getPhoenixFulfillmentConfigPublicKey)(this.program.programId, phoenixMarket);
         return (await this.program.account.phoenixV1FulfillmentConfig.fetch(address));
     }
+    async getPhoenixV1FulfillmentConfigs() {
+        const accounts = await this.program.account.phoenixV1FulfillmentConfig.all();
+        return accounts.map((account) => account.account);
+    }
     async fetchMarketLookupTableAccount() {
         if (this.lookupTableAccount)
             return this.lookupTableAccount;
@@ -1510,6 +1518,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 +1564,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 +1784,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 +1904,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 +2518,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 +2549,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 +2570,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 +2582,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 +2693,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 +2891,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 +3673,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 +3695,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/math/spotBalance.js

@@ -237,6 +237,12 @@ function calculateSpotMarketBorrowCapacity(spotMarketAccount, targetBorrowRate)
     else {
         remainingCapacity = anchor_1.BN.max(numericConstants_1.ZERO, totalCapacity.sub(tokenBorrowAmount));
     }
+    if (spotMarketAccount.maxTokenBorrowsFraction > 0) {
+        const maxTokenBorrows = spotMarketAccount.maxTokenDeposits
+            .mul(new anchor_1.BN(spotMarketAccount.maxTokenBorrowsFraction))
+            .divn(10000);
+        remainingCapacity = anchor_1.BN.min(remainingCapacity, anchor_1.BN.max(numericConstants_1.ZERO, maxTokenBorrows.sub(tokenBorrowAmount)));
+    }
     return { totalCapacity, remainingCapacity };
 }
 exports.calculateSpotMarketBorrowCapacity = calculateSpotMarketBorrowCapacity;
@@ -260,7 +266,7 @@ function calculateInterestRate(bank, delta = numericConstants_1.ZERO) {
             .mul(borrowRateSlope)
             .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
     }
-    return interestRate;
+    return anchor_1.BN.max(interestRate, new anchor_1.BN(bank.minBorrowRate).mul(numericConstants_2.PERCENTAGE_PRECISION.divn(200)));
 }
 exports.calculateInterestRate = calculateInterestRate;
 function calculateDepositRate(bank, delta = numericConstants_1.ZERO) {

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;