@drift-labs/sdk 2.83.0-beta.1 → 2.83.0-beta.11

package/VERSION

@@ -1 +1 @@
-2.83.0-beta.1
+2.83.0-beta.11

package/lib/adminClient.d.ts

@@ -7,10 +7,10 @@ export declare class AdminClient extends DriftClient {
     initialize(usdcMint: PublicKey, _adminControlsPrices: boolean): Promise<[TransactionSignature]>;
     initializeSpotMarket(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number, liquidatorFee?: number, ifLiquidationFee?: number, activeStatus?: boolean, assetTier?: {
         collateral: {};
-    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string): Promise<TransactionSignature>;
+    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string, marketIndex?: number): Promise<TransactionSignature>;
     getInitializeSpotMarketIx(mint: PublicKey, optimalUtilization: number, optimalRate: number, maxRate: number, oracle: PublicKey, oracleSource: OracleSource, initialAssetWeight: number, maintenanceAssetWeight: number, initialLiabilityWeight: number, maintenanceLiabilityWeight: number, imfFactor?: number, liquidatorFee?: number, ifLiquidationFee?: number, activeStatus?: boolean, assetTier?: {
         collateral: {};
-    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string): Promise<TransactionInstruction>;
+    }, scaleInitialAssetWeightStart?: BN, withdrawGuardThreshold?: BN, orderTickSize?: BN, orderStepSize?: BN, ifTotalFactor?: number, name?: string, marketIndex?: number): Promise<TransactionInstruction>;
     deleteInitializedSpotMarket(marketIndex: number): Promise<TransactionSignature>;
     getDeleteInitializedSpotMarketIx(marketIndex: number): Promise<TransactionInstruction>;
     initializeSerumFulfillmentConfig(marketIndex: number, serumMarket: PublicKey, serumProgram: PublicKey): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -61,12 +61,11 @@ class AdminClient extends driftClient_1.DriftClient {
         const { txSig } = await super.sendTransaction(tx, [], this.opts);
         return [txSig];
     }
-    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME) {
-        const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
-        const initializeIx = await this.getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, ifLiquidationFee, activeStatus, assetTier, scaleInitialAssetWeightStart, withdrawGuardThreshold, orderTickSize, orderStepSize, ifTotalFactor, name);
+    async initializeSpotMarket(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME, marketIndex) {
+        const spotMarketIndex = marketIndex !== null && marketIndex !== void 0 ? marketIndex : this.getStateAccount().numberOfSpotMarkets;
+        const initializeIx = await this.getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor, liquidatorFee, ifLiquidationFee, activeStatus, assetTier, scaleInitialAssetWeightStart, withdrawGuardThreshold, orderTickSize, orderStepSize, ifTotalFactor, name, marketIndex);
         const tx = await this.buildTransaction(initializeIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
-        // const { txSig } = await this.sendTransaction(initializeTx, [], this.opts);
         await this.accountSubscriber.addSpotMarket(spotMarketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
@@ -75,8 +74,8 @@ class AdminClient extends driftClient_1.DriftClient {
         await this.accountSubscriber.setSpotOracleMap();
         return txSig;
     }
-    async getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME) {
-        const spotMarketIndex = this.getStateAccount().numberOfSpotMarkets;
+    async getInitializeSpotMarketIx(mint, optimalUtilization, optimalRate, maxRate, oracle, oracleSource, initialAssetWeight, maintenanceAssetWeight, initialLiabilityWeight, maintenanceLiabilityWeight, imfFactor = 0, liquidatorFee = 0, ifLiquidationFee = 0, activeStatus = true, assetTier = types_1.AssetTier.COLLATERAL, scaleInitialAssetWeightStart = numericConstants_1.ZERO, withdrawGuardThreshold = numericConstants_1.ZERO, orderTickSize = numericConstants_1.ONE, orderStepSize = numericConstants_1.ONE, ifTotalFactor = 0, name = userName_1.DEFAULT_MARKET_NAME, marketIndex) {
+        const spotMarketIndex = marketIndex !== null && marketIndex !== void 0 ? marketIndex : this.getStateAccount().numberOfSpotMarkets;
         const spotMarket = await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex);
         const spotMarketVault = await (0, pda_1.getSpotMarketVaultPublicKey)(this.program.programId, spotMarketIndex);
         const insuranceFundVault = await (0, pda_1.getInsuranceFundVaultPublicKey)(this.program.programId, spotMarketIndex);
@@ -184,7 +183,7 @@ class AdminClient extends driftClient_1.DriftClient {
         while (this.getStateAccount().numberOfMarkets <= currentPerpMarketIndex) {
             await this.fetchAccounts();
         }
-        await this.accountSubscriber.addPerpMarket(currentPerpMarketIndex);
+        await this.accountSubscriber.addPerpMarket(marketIndex);
         await this.accountSubscriber.addOracle({
             source: oracleSource,
             publicKey: priceOracle,
@@ -193,8 +192,7 @@ class AdminClient extends driftClient_1.DriftClient {
         return txSig;
     }
     async getInitializePerpMarketIx(marketIndex, priceOracle, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier = numericConstants_1.PEG_PRECISION, oracleSource = types_1.OracleSource.PYTH, contractTier = types_1.ContractTier.SPECULATIVE, marginRatioInitial = 2000, marginRatioMaintenance = 500, liquidatorFee = 0, ifLiquidatorFee = 10000, imfFactor = 0, activeStatus = true, baseSpread = 0, maxSpread = 142500, maxOpenInterest = numericConstants_1.ZERO, maxRevenueWithdrawPerPeriod = numericConstants_1.ZERO, quoteMaxInsurance = numericConstants_1.ZERO, orderStepSize = numericConstants_1.BASE_PRECISION.divn(10000), orderTickSize = numericConstants_1.PRICE_PRECISION.divn(100000), minOrderSize = numericConstants_1.BASE_PRECISION.divn(10000), concentrationCoefScale = numericConstants_1.ONE, curveUpdateIntensity = 0, ammJitIntensity = 0, name = userName_1.DEFAULT_MARKET_NAME) {
-        const currentPerpMarketIndex = this.getStateAccount().numberOfMarkets;
-        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, currentPerpMarketIndex);
+        const perpMarketPublicKey = await (0, pda_1.getPerpMarketPublicKey)(this.program.programId, marketIndex);
         const nameBuffer = (0, userName_1.encodeName)(name);
         return await this.program.instruction.initializePerpMarket(marketIndex, baseAssetReserve, quoteAssetReserve, periodicity, pegMultiplier, oracleSource, contractTier, marginRatioInitial, marginRatioMaintenance, liquidatorFee, ifLiquidatorFee, imfFactor, activeStatus, baseSpread, maxSpread, maxOpenInterest, maxRevenueWithdrawPerPeriod, quoteMaxInsurance, orderStepSize, orderTickSize, minOrderSize, concentrationCoefScale, curveUpdateIntensity, ammJitIntensity, nameBuffer, {
             accounts: {

package/lib/clock/clockSubscriber.d.ts

@@ -11,11 +11,13 @@ export interface ClockSubscriberEvent {
 }
 export declare class ClockSubscriber {
     private connection;
-    private latestSlot;
-    currentTs: number;
+    private _latestSlot;
+    private _currentTs;
     private subscriptionId;
     commitment: Commitment;
     eventEmitter: StrictEventEmitter<EventEmitter, ClockSubscriberEvent>;
+    get latestSlot(): number;
+    get currentTs(): number;
     private timeoutId?;
     private resubTimeoutMs?;
     private isUnsubscribing;

package/lib/clock/clockSubscriber.js

@@ -5,6 +5,12 @@ const web3_js_1 = require("@solana/web3.js");
 const events_1 = require("events");
 const __1 = require("..");
 class ClockSubscriber {
+    get latestSlot() {
+        return this._latestSlot;
+    }
+    get currentTs() {
+        return this._currentTs;
+    }
     constructor(connection, config) {
         this.connection = connection;
         this.isUnsubscribing = false;
@@ -27,8 +33,8 @@ class ClockSubscriber {
                     clearTimeout(this.timeoutId);
                     this.setTimeout();
                 }
-                this.latestSlot = context.slot;
-                this.currentTs = new __1.BN(acctInfo.data.subarray(32, 39), undefined, 'le').toNumber();
+                this._latestSlot = context.slot;
+                this._currentTs = new __1.BN(acctInfo.data.subarray(32, 39), undefined, 'le').toNumber();
                 this.eventEmitter.emit('clockUpdate', this.currentTs);
             }
         }, this.commitment);

package/lib/decode/phoenix.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { MarketData, OrderId, RestingOrder } from '@ellipsis-labs/phoenix-sdk';
+import * as beet from '@metaplex-foundation/beet';
+export declare const orderIdBeet: beet.BeetArgsStruct<OrderId>;
+export declare const restingOrderBeet: beet.BeetArgsStruct<RestingOrder>;
+export declare const fastDecode: (buffer: Buffer) => MarketData;

package/lib/decode/phoenix.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fastDecode = exports.restingOrderBeet = exports.orderIdBeet = void 0;
+const phoenix_sdk_1 = require("@ellipsis-labs/phoenix-sdk");
+const beet = __importStar(require("@metaplex-foundation/beet"));
+exports.orderIdBeet = new beet.BeetArgsStruct([
+    ['priceInTicks', beet.u64],
+    ['orderSequenceNumber', beet.u64],
+], 'fIFOOrderId');
+exports.restingOrderBeet = new beet.BeetArgsStruct([
+    ['traderIndex', beet.u64],
+    ['numBaseLots', beet.u64],
+    ['lastValidSlot', beet.u64],
+    ['lastValidUnixTimestampInSeconds', beet.u64],
+], 'fIFORestingOrder');
+function deserializeRedBlackTree(data, keyDeserializer, valueDeserializer) {
+    const tree = new Map();
+    const treeNodes = deserializeRedBlackTreeNodes(data, keyDeserializer, valueDeserializer);
+    const nodes = treeNodes[0];
+    const freeNodes = treeNodes[1];
+    for (const [index, [key, value]] of nodes.entries()) {
+        if (!freeNodes.has(index)) {
+            tree.set(key, value);
+        }
+    }
+    return tree;
+}
+function deserializeRedBlackTreeNodes(data, keyDeserializer, valueDeserializer) {
+    let offset = 0;
+    const keySize = keyDeserializer.byteSize;
+    const valueSize = valueDeserializer.byteSize;
+    const nodes = new Array();
+    // Skip RBTree header
+    offset += 16;
+    // Skip node allocator size
+    offset += 8;
+    const bumpIndex = data.readInt32LE(offset);
+    offset += 4;
+    let freeListHead = data.readInt32LE(offset);
+    offset += 4;
+    const freeListPointers = new Array();
+    for (let index = 0; offset < data.length && index < bumpIndex - 1; index++) {
+        const registers = new Array();
+        for (let i = 0; i < 4; i++) {
+            registers.push(data.readInt32LE(offset)); // skip padding
+            offset += 4;
+        }
+        const [key] = keyDeserializer.deserialize(data.subarray(offset, offset + keySize));
+        offset += keySize;
+        const [value] = valueDeserializer.deserialize(data.subarray(offset, offset + valueSize));
+        offset += valueSize;
+        nodes.push([key, value]);
+        freeListPointers.push([index, registers[0]]);
+    }
+    const freeNodes = new Set();
+    let indexToRemove = freeListHead - 1;
+    let counter = 0;
+    // If there's an infinite loop here, that means that the state is corrupted
+    while (freeListHead < bumpIndex) {
+        // We need to subtract 1 because the node allocator is 1-indexed
+        const next = freeListPointers[freeListHead - 1];
+        [indexToRemove, freeListHead] = next;
+        freeNodes.add(indexToRemove);
+        counter += 1;
+        if (counter > bumpIndex) {
+            throw new Error('Infinite loop detected');
+        }
+    }
+    return [nodes, freeNodes];
+}
+const fastDecode = (buffer) => {
+    let offset = phoenix_sdk_1.marketHeaderBeet.byteSize;
+    const [header] = phoenix_sdk_1.marketHeaderBeet.deserialize(buffer.subarray(0, offset));
+    const paddingLen = 8 * 32;
+    let remaining = buffer.subarray(offset + paddingLen);
+    offset = 0;
+    const baseLotsPerBaseUnit = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    const quoteLotsPerBaseUnitPerTick = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    const sequenceNumber = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    const takerFeeBps = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    const collectedQuoteLotFees = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    const unclaimedQuoteLotFees = Number(remaining.readBigUInt64LE(offset));
+    offset += 8;
+    remaining = remaining.subarray(offset);
+    const totalNumBids = (0, phoenix_sdk_1.toNum)(header.marketSizeParams.bidsSize);
+    const totalNumAsks = (0, phoenix_sdk_1.toNum)(header.marketSizeParams.asksSize);
+    const totalBidsSize = 16 +
+        16 +
+        (16 + exports.orderIdBeet.byteSize + exports.restingOrderBeet.byteSize) * totalNumBids;
+    const totalAsksSize = 16 +
+        16 +
+        (16 + exports.orderIdBeet.byteSize + exports.restingOrderBeet.byteSize) * totalNumAsks;
+    offset = 0;
+    const bidBuffer = remaining.subarray(offset, offset + totalBidsSize);
+    offset += totalBidsSize;
+    const askBuffer = remaining.subarray(offset, offset + totalAsksSize);
+    const bidsUnsorted = deserializeRedBlackTree(bidBuffer, exports.orderIdBeet, exports.restingOrderBeet);
+    const asksUnsorted = deserializeRedBlackTree(askBuffer, exports.orderIdBeet, exports.restingOrderBeet);
+    const bids = [...bidsUnsorted].sort((a, b) => {
+        const priceComparison = (0, phoenix_sdk_1.sign)((0, phoenix_sdk_1.toBN)(b[0].priceInTicks).sub((0, phoenix_sdk_1.toBN)(a[0].priceInTicks)));
+        if (priceComparison !== 0) {
+            return priceComparison;
+        }
+        return (0, phoenix_sdk_1.sign)((0, phoenix_sdk_1.getUiOrderSequenceNumber)(a[0]).sub((0, phoenix_sdk_1.getUiOrderSequenceNumber)(b[0])));
+    });
+    const asks = [...asksUnsorted].sort((a, b) => {
+        const priceComparison = (0, phoenix_sdk_1.sign)((0, phoenix_sdk_1.toBN)(a[0].priceInTicks).sub((0, phoenix_sdk_1.toBN)(b[0].priceInTicks)));
+        if (priceComparison !== 0) {
+            return priceComparison;
+        }
+        return (0, phoenix_sdk_1.sign)((0, phoenix_sdk_1.getUiOrderSequenceNumber)(a[0]).sub((0, phoenix_sdk_1.getUiOrderSequenceNumber)(b[0])));
+    });
+    const traders = new Map();
+    const traderPubkeyToTraderIndex = new Map();
+    const traderIndexToTraderPubkey = new Map();
+    return {
+        header,
+        baseLotsPerBaseUnit,
+        quoteLotsPerBaseUnitPerTick,
+        sequenceNumber,
+        takerFeeBps,
+        collectedQuoteLotFees,
+        unclaimedQuoteLotFees,
+        bids,
+        asks,
+        traders,
+        traderPubkeyToTraderIndex,
+        traderIndexToTraderPubkey,
+    };
+};
+exports.fastDecode = fastDecode;

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 } 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 } 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';
@@ -447,7 +447,7 @@ 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>;
-    placeAndTakePerpWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, simulateFirst?: boolean): Promise<{
+    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;
         signedSettlePnlTx?: Transaction;
@@ -600,6 +600,8 @@ export declare class DriftClient {
     }[], marketIndexes: number[]): Promise<Array<TransactionInstruction>>;
     settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
+    settleMultiplePNLs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams): Promise<TransactionSignature>;
+    settleMultiplePNLsIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode): Promise<TransactionInstruction>;
     liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
     getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
     liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
@@ -680,6 +682,7 @@ export declare class DriftClient {
         marketType: MarketType;
     } | undefined;
     private handleSignedTransaction;
+    private handlePreSignedTransaction;
     private isVersionedTransaction;
     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>;

package/lib/driftClient.js

@@ -104,6 +104,7 @@ class DriftClient {
                 opts: {
                     returnBlockHeightsWithSignedTxCallbackData: config.enableMetricsEvents,
                     onSignedCb: this.handleSignedTransaction.bind(this),
+                    preSignedCb: this.handlePreSignedTransaction.bind(this),
                 },
             });
         if (config.includeDelegates && config.subAccountIds) {
@@ -2499,63 +2500,82 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, simulateFirst) {
-        var _a;
+    async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails) {
         const placeAndTakeIxs = [];
-        const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId);
         const txsToSign = [];
         const keys = {
             placeAndTakeIx: 'placeAndTakeIx',
             cancelExistingOrdersTx: 'cancelExistingOrdersTx',
             settlePnlTx: 'settlePnlTx',
         };
-        placeAndTakeIxs.push(placeAndTakeIx);
-        if (bracketOrdersParams.length > 0) {
-            const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
-            placeAndTakeIxs.push(bracketOrdersIx);
-        }
-        const shouldUseSimulationComputeUnits = txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits;
-        const shouldExitIfSimulationFails = simulateFirst;
-        const txParamsWithoutImplicitSimulation = {
-            ...txParams,
-            useSimulatedComputeUnits: false,
-        };
         // 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();
-        if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
-            const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParamsWithoutImplicitSimulation, undefined, undefined, true, recentBlockHash));
-            const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2);
-            if (shouldExitIfSimulationFails && !simulationResult.success) {
-                return;
+        let earlyExitFailedPlaceAndTakeSim = false;
+        const prepPlaceAndTakeTx = async () => {
+            var _a;
+            const placeAndTakeIx = await this.getPlaceAndTakePerpOrderIx(orderParams, makerInfo, referrerInfo, subAccountId);
+            placeAndTakeIxs.push(placeAndTakeIx);
+            if (bracketOrdersParams.length > 0) {
+                const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
+                placeAndTakeIxs.push(bracketOrdersIx);
             }
-            txsToSign.push({
-                key: keys.placeAndTakeIx,
-                tx: 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),
-            });
-        }
-        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),
-            });
-        }
-        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),
-            });
+            const shouldUseSimulationComputeUnits = txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits;
+            const shouldExitIfSimulationFails = exitEarlyIfSimFails;
+            const txParamsWithoutImplicitSimulation = {
+                ...txParams,
+                useSimulatedComputeUnits: false,
+            };
+            if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+                const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, true, recentBlockHash));
+                const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2);
+                if (shouldExitIfSimulationFails && !simulationResult.success) {
+                    earlyExitFailedPlaceAndTakeSim = true;
+                    return;
+                }
+                txsToSign.push({
+                    key: keys.placeAndTakeIx,
+                    tx: 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),
+                });
+            }
+            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),
+                });
+            }
+            return;
+        };
+        const prepSettlePnlTx = async () => {
+            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),
+                });
+            }
+            return;
+        };
+        await Promise.all([
+            prepPlaceAndTakeTx(),
+            prepCancelOrderTx(),
+            prepSettlePnlTx(),
+        ]);
+        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);
@@ -2984,6 +3004,26 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
+    async settleMultiplePNLs(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode, txParams) {
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode), txParams), [], this.opts);
+        return txSig;
+    }
+    async settleMultiplePNLsIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndexes, mode) {
+        const remainingAccounts = this.getRemainingAccounts({
+            userAccounts: [settleeUserAccount],
+            writablePerpMarketIndexes: marketIndexes,
+            writableSpotMarketIndexes: [numericConstants_1.QUOTE_SPOT_MARKET_INDEX],
+        });
+        return await this.program.instruction.settleMultiplePnls(marketIndexes, mode, {
+            accounts: {
+                state: await this.getStatePublicKey(),
+                authority: this.wallet.publicKey,
+                user: settleeUserAccountPublicKey,
+                spotMarketVault: this.getQuoteSpotMarketAccount().vault,
+            },
+            remainingAccounts: remainingAccounts,
+        });
+    }
     async liquidatePerp(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, txParams, liquidatorSubAccountId) {
         const { txSig, slot } = await this.sendTransaction(await this.buildTransaction(await this.getLiquidatePerpIx(userAccountPublicKey, userAccount, marketIndex, maxBaseAssetAmount, limitPrice, liquidatorSubAccountId), txParams), [], this.opts);
         this.perpMarketLastSlotCache.set(marketIndex, slot);
@@ -3574,6 +3614,11 @@ class DriftClient {
             this.metricsEventEmitter.emit('txSigned', signedTxs);
         }
     }
+    handlePreSignedTransaction() {
+        if (this.enableMetricsEvents && this.metricsEventEmitter) {
+            this.metricsEventEmitter.emit('preTxSigned');
+        }
+    }
     isVersionedTransaction(tx) {
         const version = tx === null || tx === void 0 ? void 0 : tx.version;
         const isVersionedTx = tx instanceof web3_js_1.VersionedTransaction || version !== undefined;

package/lib/idl/drift.json

@@ -1527,6 +1527,45 @@
                 }
             ]
         },
+        {
+            "name": "settleMultiplePnls",
+            "accounts": [
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "user",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "authority",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "spotMarketVault",
+                    "isMut": false,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "marketIndexes",
+                    "type": {
+                        "vec": "u16"
+                    }
+                },
+                {
+                    "name": "mode",
+                    "type": {
+                        "defined": "SettlePnlMode"
+                    }
+                }
+            ]
+        },
         {
             "name": "settleFundingPayment",
             "accounts": [
@@ -9411,6 +9450,20 @@
                 ]
             }
         },
+        {
+            "name": "SettlePnlMode",
+            "type": {
+                "kind": "enum",
+                "variants": [
+                    {
+                        "name": "MustSettle"
+                    },
+                    {
+                        "name": "TrySettle"
+                    }
+                ]
+            }
+        },
         {
             "name": "SpotBalanceType",
             "type": {
@@ -11899,6 +11952,16 @@
             "code": 6258,
             "name": "InsuranceFundOperationPaused",
             "msg": "InsuranceFundOperationPaused"
+        },
+        {
+            "code": 6259,
+            "name": "NoUnsettledPnl",
+            "msg": "NoUnsettledPnl"
+        },
+        {
+            "code": 6260,
+            "name": "PnlPoolCantSettleUser",
+            "msg": "PnlPoolCantSettleUser"
         }
     ]
 }

package/lib/index.d.ts

@@ -77,6 +77,7 @@ export * from './tx/whileValidTxSender';
 export * from './tx/priorityFeeCalculator';
 export * from './tx/forwardOnlyTxSender';
 export * from './tx/types';
+export * from './tx/txHandler';
 export * from './util/computeUnits';
 export * from './util/tps';
 export * from './util/promiseTimeout';

package/lib/index.js

@@ -100,6 +100,7 @@ __exportStar(require("./tx/whileValidTxSender"), exports);
 __exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/forwardOnlyTxSender"), exports);
 __exportStar(require("./tx/types"), exports);
+__exportStar(require("./tx/txHandler"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);
 __exportStar(require("./util/promiseTimeout"), exports);

package/lib/math/auction.js

@@ -69,7 +69,7 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     const deltaDenominator = new _1.BN(order.auctionDuration);
     const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
     if (deltaDenominator.eq(_1.ZERO)) {
-        return oraclePrice.add(order.auctionEndPrice);
+        return _1.BN.max(oraclePrice.add(order.auctionEndPrice), _1.ONE);
     }
     let priceOffsetDelta;
     if ((0, types_1.isVariant)(order.direction, 'long')) {
@@ -91,7 +91,7 @@ function getAuctionPriceForOracleOffsetAuction(order, slot, oraclePrice) {
     else {
         priceOffset = order.auctionStartPrice.sub(priceOffsetDelta);
     }
-    return oraclePrice.add(priceOffset);
+    return _1.BN.max(oraclePrice.add(priceOffset), _1.ONE);
 }
 exports.getAuctionPriceForOracleOffsetAuction = getAuctionPriceForOracleOffsetAuction;
 function deriveOracleAuctionParams({ direction, oraclePrice, auctionStartPrice, auctionEndPrice, limitPrice, }) {

package/lib/math/market.js

@@ -112,10 +112,13 @@ function calculateMarketMaxAvailableInsurance(perpMarket, spotMarket) {
 exports.calculateMarketMaxAvailableInsurance = calculateMarketMaxAvailableInsurance;
 function calculateNetUserPnl(perpMarket, oraclePriceData) {
     const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
+        .add(perpMarket.amm.baseAssetAmountWithUnsettledLp)
         .mul(oraclePriceData.price)
         .div(numericConstants_1.BASE_PRECISION)
         .div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
-    const netUserCostBasis = perpMarket.amm.quoteAssetAmount;
+    const netUserCostBasis = perpMarket.amm.quoteAssetAmount
+        .add(perpMarket.amm.quoteAssetAmountWithUnsettledLp)
+        .add(perpMarket.amm.netUnsettledFundingPnl);
     const netUserPnl = netUserPositionValue.add(netUserCostBasis);
     return netUserPnl;
 }

package/lib/math/orders.js

@@ -102,7 +102,7 @@ function getLimitPrice(order, oraclePriceData, slot, fallbackPrice) {
         limitPrice = (0, auction_1.getAuctionPrice)(order, slot, oraclePriceData.price);
     }
     else if (order.oraclePriceOffset !== 0) {
-        limitPrice = oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset));
+        limitPrice = anchor_1.BN.max(oraclePriceData.price.add(new anchor_1.BN(order.oraclePriceOffset)), numericConstants_1.ONE);
     }
     else if (order.price.eq(numericConstants_1.ZERO)) {
         limitPrice = fallbackPrice;