@drift-labs/sdk 2.49.0-beta.3 → 2.49.0-beta.5

package/VERSION

@@ -1 +1 @@
-2.49.0-beta.3
+2.49.0-beta.5

package/lib/dlob/DLOB.d.ts

@@ -68,11 +68,15 @@ export declare class DLOB {
     updateRestingLimitOrdersForMarketType(slot: number, marketTypeStr: MarketTypeStr): void;
     getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
+    getMakerRebate(marketType: MarketType, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): {
+        makerRebateNumerator: number;
+        makerRebateDenominator: number;
+    };
     mergeNodesToFill(restingLimitOrderNodesToFill: NodeToFill[], takingOrderNodesToFill: NodeToFill[]): NodeToFill[];
-    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
+    findRestingLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, makerRebateNumerator: number, makerRebateDenominator: number, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findTakingNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, minAuctionDuration: number, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
     findTakingNodesCrossingMakerNodes(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, takerNodeGenerator: Generator<DLOBNode>, makerNodeGeneratorFn: (marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData) => Generator<DLOBNode>, doesCross: (takerPrice: BN | undefined, makerPrice: BN) => boolean): NodeToFill[];
-    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, fallbackPrice: BN, doesCross: (nodePrice: BN | undefined, fallbackPrice: BN) => boolean, minAuctionDuration: number): NodeToFill[];
+    findNodesCrossingFallbackLiquidity(marketType: MarketType, slot: number, oraclePriceData: OraclePriceData, nodeGenerator: Generator<DLOBNode>, doesCross: (nodePrice: BN | undefined) => boolean, minAuctionDuration: number): NodeToFill[];
     findExpiredNodesToFill(marketIndex: number, ts: number, marketType: MarketType): NodeToFill[];
     findJitAuctionNodesToFill(marketIndex: number, slot: number, oraclePriceData: OraclePriceData, marketType: MarketType): NodeToFill[];
     getTakingBids(marketIndex: number, marketType: MarketType, slot: number, oraclePriceData: OraclePriceData): Generator<DLOBNode>;

package/lib/dlob/DLOB.js

@@ -304,7 +304,8 @@ class DLOB {
         const minAuctionDuration = (0, __1.isVariant)(marketType, 'perp')
             ? stateAccount.minPerpAuctionDuration
             : 0;
-        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
+        const { makerRebateNumerator, makerRebateDenominator } = this.getMakerRebate(marketType, stateAccount, marketAccount);
+        const restingLimitOrderNodesToFill = this.findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid);
         const takingOrderNodesToFill = this.findTakingNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid);
         // get expired market nodes
         const expiredNodesToFill = this.findExpiredNodesToFill(marketIndex, ts, marketType);
@@ -314,6 +315,28 @@ class DLOB {
         }
         return this.mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill).concat(expiredNodesToFill);
     }
+    getMakerRebate(marketType, stateAccount, marketAccount) {
+        let makerRebateNumerator;
+        let makerRebateDenominator;
+        if ((0, __1.isVariant)(marketType, 'perp')) {
+            makerRebateNumerator =
+                stateAccount.perpFeeStructure.feeTiers[0].makerRebateNumerator;
+            makerRebateDenominator =
+                stateAccount.perpFeeStructure.feeTiers[0].makerRebateDenominator;
+        }
+        else {
+            makerRebateNumerator =
+                stateAccount.spotFeeStructure.feeTiers[0].makerRebateNumerator;
+            makerRebateDenominator =
+                stateAccount.spotFeeStructure.feeTiers[0].makerRebateDenominator;
+        }
+        // @ts-ignore
+        const feeAdjustment = marketAccount.feeAdjustment || 0;
+        if (feeAdjustment !== 0) {
+            makerRebateNumerator += (makerRebateNumerator * feeAdjustment) / 100;
+        }
+        return { makerRebateNumerator, makerRebateDenominator };
+    }
     mergeNodesToFill(restingLimitOrderNodesToFill, takingOrderNodesToFill) {
         const mergedNodesToFill = new Map();
         const mergeNodesToFillHelper = (nodesToFillArray) => {
@@ -336,7 +359,7 @@ class DLOB {
         mergeNodesToFillHelper(takingOrderNodesToFill);
         return Array.from(mergedNodesToFill.values());
     }
-    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, fallbackAsk, fallbackBid) {
+    findRestingLimitOrderNodesToFill(marketIndex, slot, marketType, oraclePriceData, isAmmPaused, minAuctionDuration, makerRebateNumerator, makerRebateDenominator, fallbackAsk, fallbackBid) {
         const nodesToFill = new Array();
         const crossingNodes = this.findCrossingRestingLimitOrders(marketIndex, slot, marketType, oraclePriceData);
         for (const crossingNode of crossingNodes) {
@@ -344,8 +367,9 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             const askGenerator = this.getRestingLimitAsks(marketIndex, slot, marketType, oraclePriceData);
-            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, fallbackBid, (askPrice, fallbackPrice) => {
-                return askPrice.lte(fallbackPrice);
+            const fallbackBidWithBuffer = fallbackBid.sub(fallbackBid.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const asksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, askGenerator, (askPrice) => {
+                return askPrice.lte(fallbackBidWithBuffer);
             }, minAuctionDuration);
             for (const askCrossingFallback of asksCrossingFallback) {
                 nodesToFill.push(askCrossingFallback);
@@ -353,8 +377,9 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             const bidGenerator = this.getRestingLimitBids(marketIndex, slot, marketType, oraclePriceData);
-            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, fallbackAsk, (bidPrice, fallbackPrice) => {
-                return bidPrice.gte(fallbackPrice);
+            const fallbackAskWithBuffer = fallbackAsk.add(fallbackAsk.muln(makerRebateNumerator).divn(makerRebateDenominator));
+            const bidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, bidGenerator, (bidPrice) => {
+                return bidPrice.gte(fallbackAskWithBuffer);
             }, minAuctionDuration);
             for (const bidCrossingFallback of bidsCrossingFallback) {
                 nodesToFill.push(bidCrossingFallback);
@@ -381,8 +406,8 @@ class DLOB {
         }
         if (fallbackBid && !isAmmPaused) {
             takingOrderGenerator = this.getTakingAsks(marketIndex, marketType, slot, oraclePriceData);
-            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackBid, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.lte(fallbackPrice);
+            const takingAsksCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.lte(fallbackBid);
             }, minAuctionDuration);
             for (const takingAskCrossingFallback of takingAsksCrossingFallback) {
                 nodesToFill.push(takingAskCrossingFallback);
@@ -405,8 +430,8 @@ class DLOB {
         }
         if (fallbackAsk && !isAmmPaused) {
             takingOrderGenerator = this.getTakingBids(marketIndex, marketType, slot, oraclePriceData);
-            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, fallbackAsk, (takerPrice, fallbackPrice) => {
-                return takerPrice === undefined || takerPrice.gte(fallbackPrice);
+            const takingBidsCrossingFallback = this.findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, takingOrderGenerator, (takerPrice) => {
+                return takerPrice === undefined || takerPrice.gte(fallbackAsk);
             }, minAuctionDuration);
             for (const marketBidCrossingFallback of takingBidsCrossingFallback) {
                 nodesToFill.push(marketBidCrossingFallback);
@@ -456,7 +481,7 @@ class DLOB {
         }
         return nodesToFill;
     }
-    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, fallbackPrice, doesCross, minAuctionDuration) {
+    findNodesCrossingFallbackLiquidity(marketType, slot, oraclePriceData, nodeGenerator, doesCross, minAuctionDuration) {
         var _a;
         const nodesToFill = new Array();
         let nextNode = nodeGenerator.next();
@@ -468,7 +493,7 @@ class DLOB {
             }
             const nodePrice = (0, __1.getLimitPrice)(node.order, oraclePriceData, slot);
             // order crosses if there is no limit price or it crosses fallback price
-            const crosses = doesCross(nodePrice, fallbackPrice);
+            const crosses = doesCross(nodePrice);
             // fallback is available if auction is complete or it's a spot order
             const fallbackAvailable = (0, __1.isVariant)(marketType, 'spot') ||
                 (0, __1.isFallbackAvailableLiquiditySource)(node.order, minAuctionDuration, slot);

package/lib/driftClient.d.ts

@@ -149,7 +149,7 @@ export declare class DriftClient {
      */
     forceGetUserAccount(subAccountId?: number): Promise<UserAccount | undefined>;
     getUserAccountAndSlot(subAccountId?: number): DataAndSlot<UserAccount> | undefined;
-    getSpotPosition(marketIndex: number): SpotPosition | undefined;
+    getSpotPosition(marketIndex: number, subAccountId?: number): SpotPosition | undefined;
     getQuoteAssetTokenAmount(): BN;
     /**
      * Returns the token amount for a given market. The spot market precision is based on the token mint decimals.
@@ -192,8 +192,8 @@ export declare class DriftClient {
         spotMarketAccountMap: Map<number, AccountMeta>;
         perpMarketAccountMap: Map<number, AccountMeta>;
     };
-    getOrder(orderId: number): Order | undefined;
-    getOrderByUserId(userOrderId: number): Order | undefined;
+    getOrder(orderId: number, subAccountId?: number): Order | undefined;
+    getOrderByUserId(userOrderId: number, subAccountId?: number): Order | undefined;
     /**
      * Get the associated token address for the given spot market
      * @param marketIndex
@@ -204,11 +204,11 @@ export declare class DriftClient {
     /**
      * Deposit funds into the given spot market
      *
-     * @param amount
-     * @param marketIndex
+     * @param amount to deposit
+     * @param marketIndex spot market index to deposit into
      * @param associatedTokenAccount can be the wallet public key if using native sol
-     * @param subAccountId
-     * @param reduceOnly
+     * @param subAccountId subaccountId to deposit
+     * @param reduceOnly if true, deposit must not increase account risk
      */
     deposit(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean): Promise<TransactionSignature>;
     getDepositInstruction(amount: BN, marketIndex: number, userTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, userInitialized?: boolean): Promise<TransactionInstruction>;
@@ -239,8 +239,8 @@ export declare class DriftClient {
      * @param associatedTokenAddress - the token account to withdraw to. can be the wallet public key if using native sol
      * @param reduceOnly
      */
-    withdraw(amount: BN, marketIndex: number, associatedTokenAddress: PublicKey, reduceOnly?: boolean): Promise<TransactionSignature>;
-    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean): Promise<TransactionInstruction>;
+    withdraw(amount: BN, marketIndex: number, associatedTokenAddress: PublicKey, reduceOnly?: boolean, subAccountId?: number): Promise<TransactionSignature>;
+    getWithdrawIx(amount: BN, marketIndex: number, userTokenAccount: PublicKey, reduceOnly?: boolean, subAccountId?: number): Promise<TransactionInstruction>;
     /**
      * Withdraws from the fromSubAccount and deposits into the toSubAccount
      * @param amount
@@ -255,17 +255,17 @@ export declare class DriftClient {
     updateSpotMarketCumulativeInterestIx(marketIndex: number): Promise<TransactionInstruction>;
     settleLP(settleeUserAccountPublicKey: PublicKey, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     settleLPIx(settleeUserAccountPublicKey: PublicKey, marketIndex: number): Promise<TransactionInstruction>;
-    removePerpLpShares(marketIndex: number, sharesToBurn?: BN, txParams?: TxParams): Promise<TransactionSignature>;
+    removePerpLpShares(marketIndex: number, sharesToBurn?: BN, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     removePerpLpSharesInExpiringMarket(marketIndex: number, userAccountPublicKey: PublicKey, sharesToBurn?: BN, txParams?: TxParams): Promise<TransactionSignature>;
     getRemovePerpLpSharesInExpiringMarket(marketIndex: number, userAccountPublicKey: PublicKey, sharesToBurn?: BN): Promise<TransactionInstruction>;
-    getRemovePerpLpSharesIx(marketIndex: number, sharesToBurn?: BN): Promise<TransactionInstruction>;
-    addPerpLpShares(amount: BN, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getAddPerpLpSharesIx(amount: BN, marketIndex: number): Promise<TransactionInstruction>;
+    getRemovePerpLpSharesIx(marketIndex: number, sharesToBurn?: BN, subAccountId?: number): Promise<TransactionInstruction>;
+    addPerpLpShares(amount: BN, marketIndex: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getAddPerpLpSharesIx(amount: BN, marketIndex: number, subAccountId?: number): Promise<TransactionInstruction>;
     getQuoteValuePerLpShare(marketIndex: number): BN;
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
-    openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    openPosition(direction: PositionDirection, amount: BN, marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
     sendSignedTx(tx: Transaction): Promise<TransactionSignature>;
     /**
      * 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.
@@ -283,35 +283,35 @@ export declare class DriftClient {
         signedFillTx?: Transaction;
         signedCancelExistingOrdersTx?: Transaction;
     }>;
-    placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlacePerpOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    placePerpOrder(orderParams: OptionalOrderParams, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getPlacePerpOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
     updateAMMs(marketIndexes: number[], txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateAMMsIx(marketIndexes: number[]): Promise<TransactionInstruction>;
     settleExpiredMarket(marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
     getSettleExpiredMarketIx(marketIndex: number): Promise<TransactionInstruction>;
     settleExpiredMarketPoolsToRevenuePool(perpMarketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
-    cancelOrder(orderId?: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getCancelOrderIx(orderId?: number): Promise<TransactionInstruction>;
-    cancelOrderByUserId(userOrderId: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getCancelOrderByUserIdIx(userOrderId: number): Promise<TransactionInstruction>;
-    cancelOrdersByIds(orderIds?: number[], txParams?: TxParams): Promise<TransactionSignature>;
-    getCancelOrdersByIdsIx(orderIds?: number[]): Promise<TransactionInstruction>;
-    cancelOrders(marketType?: MarketType, marketIndex?: number, direction?: PositionDirection, txParams?: TxParams): Promise<TransactionSignature>;
-    getCancelOrdersIx(marketType: MarketType | null, marketIndex: number | null, direction: PositionDirection | null): Promise<TransactionInstruction>;
+    cancelOrder(orderId?: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getCancelOrderIx(orderId?: number, subAccountId?: number): Promise<TransactionInstruction>;
+    cancelOrderByUserId(userOrderId: number, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getCancelOrderByUserIdIx(userOrderId: number, subAccountId?: number): Promise<TransactionInstruction>;
+    cancelOrdersByIds(orderIds?: number[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getCancelOrdersByIdsIx(orderIds?: number[], subAccountId?: number): Promise<TransactionInstruction>;
+    cancelOrders(marketType?: MarketType, marketIndex?: number, direction?: PositionDirection, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getCancelOrdersIx(marketType: MarketType | null, marketIndex: number | null, direction: PositionDirection | null, subAccountId?: number): Promise<TransactionInstruction>;
     cancelAndPlaceOrders(cancelOrderParams: {
         marketType?: MarketType;
         marketIndex?: number;
         direction?: PositionDirection;
-    }, placeOrderParams: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
-    placeOrders(params: OrderParams[], txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceOrdersIx(params: OrderParams[]): Promise<TransactionInstruction>;
-    fillPerpOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getFillPerpOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Pick<Order, 'marketIndex' | 'orderId'>, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
-    getRevertFillIx(): Promise<TransactionInstruction>;
-    placeSpotOrder(orderParams: OptionalOrderParams, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceSpotOrderIx(orderParams: OptionalOrderParams): Promise<TransactionInstruction>;
+    }, placeOrderParams: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
+    getPlaceOrdersIx(params: OrderParams[], 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>;
+    getPlaceSpotOrderIx(orderParams: OptionalOrderParams, subAccountId?: number): Promise<TransactionInstruction>;
     fillSpotOrder(userAccountPublicKey: PublicKey, user: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    getFillSpotOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order?: Order, fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
     addSpotFulfillmentAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig?: SerumV3FulfillmentConfigAccount | PhoenixV1FulfillmentConfigAccount): void;
     addSerumRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: SerumV3FulfillmentConfigAccount): void;
     addPhoenixRemainingAccounts(marketIndex: number, remainingAccounts: AccountMeta[], fulfillmentConfig: PhoenixV1FulfillmentConfigAccount): void;
@@ -412,26 +412,26 @@ export declare class DriftClient {
         amount: BN;
         userAccountPublicKey?: PublicKey;
     }): Promise<TransactionInstruction[]>;
-    triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, txParams?: TxParams): Promise<TransactionSignature>;
-    getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order): Promise<TransactionInstruction>;
-    forceCancelOrders(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
-    getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
-    updateUserIdle(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
-    getUpdateUserIdleIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
-    updateUserOpenOrdersCount(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams): Promise<TransactionSignature>;
-    getUpdateUserOpenOrdersCountIx(userAccountPublicKey: PublicKey, userAccount: UserAccount): Promise<TransactionInstruction>;
-    placeAndTakePerpOrder(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceAndTakePerpOrderIx(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
-    placeAndMakePerpOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceAndMakePerpOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
-    placeAndTakeSpotOrder(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceAndTakeSpotOrderIx(orderParams: OptionalOrderParams, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, makerInfo?: MakerInfo, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
-    placeAndMakeSpotOrder(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<TransactionSignature>;
-    getPlaceAndMakeSpotOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo): Promise<TransactionInstruction>;
+    triggerOrder(userAccountPublicKey: PublicKey, user: UserAccount, order: Order, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
+    getTriggerOrderIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, order: Order, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    forceCancelOrders(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
+    getForceCancelOrdersIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    updateUserIdle(userAccountPublicKey: PublicKey, user: UserAccount, txParams?: TxParams, fillerPublicKey?: PublicKey): Promise<TransactionSignature>;
+    getUpdateUserIdleIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, fillerPublicKey?: PublicKey): Promise<TransactionInstruction>;
+    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>;
+    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>;
+    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>;
+    getPlaceAndMakeSpotOrderIx(orderParams: OptionalOrderParams, takerInfo: TakerInfo, fulfillmentConfig?: SerumV3FulfillmentConfigAccount, referrerInfo?: ReferrerInfo, subAccountId?: number): Promise<TransactionInstruction>;
     /**
      * @deprecated use {@link placePerpOrder} or {@link placeAndTakePerpOrder} instead
      */
-    closePosition(marketIndex: number, limitPrice?: BN): Promise<TransactionSignature>;
+    closePosition(marketIndex: number, limitPrice?: BN, subAccountId?: number): Promise<TransactionSignature>;
     /**
      * Modifies an open order by closing it and replacing it with a new order.
      * @deprecated use modifyOrder instead
@@ -486,7 +486,7 @@ export declare class DriftClient {
         immediateOrCancel?: boolean;
         maxTs?: BN;
         policy?: ModifyOrderPolicy;
-    }, txParams?: TxParams): Promise<TransactionSignature>;
+    }, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getModifyOrderIx({ orderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }: {
         orderId: number;
         newDirection?: PositionDirection;
@@ -503,7 +503,7 @@ export declare class DriftClient {
         immediateOrCancel?: boolean;
         maxTs?: BN;
         policy?: ModifyOrderPolicy;
-    }): Promise<TransactionInstruction>;
+    }, subAccountId?: number): Promise<TransactionInstruction>;
     /**
      * Modifies an open order by closing it and replacing it with a new order.
      * @param orderParams.userOrderId: The open order to modify
@@ -538,7 +538,7 @@ export declare class DriftClient {
         immediateOrCancel?: boolean;
         policy?: ModifyOrderPolicy;
         maxTs?: BN;
-    }, txParams?: TxParams): Promise<TransactionSignature>;
+    }, txParams?: TxParams, subAccountId?: number): Promise<TransactionSignature>;
     getModifyOrderByUserIdIx({ userOrderId, newDirection, newBaseAmount, newLimitPrice, newOraclePriceOffset, newTriggerPrice, newTriggerCondition, auctionDuration, auctionStartPrice, auctionEndPrice, reduceOnly, postOnly, immediateOrCancel, maxTs, policy, }: {
         userOrderId: number;
         newDirection?: PositionDirection;
@@ -556,7 +556,7 @@ export declare class DriftClient {
         policy?: ModifyOrderPolicy;
         maxTs?: BN;
         txParams?: TxParams;
-    }): Promise<TransactionInstruction>;
+    }, subAccountId?: number): Promise<TransactionInstruction>;
     settlePNLs(users: {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
@@ -567,18 +567,18 @@ 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>;
-    liquidatePerp(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN, txParams?: TxParams): Promise<TransactionSignature>;
-    getLiquidatePerpIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, maxBaseAssetAmount: BN, limitPrice?: BN): Promise<TransactionInstruction>;
-    liquidateSpot(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams): Promise<TransactionSignature>;
-    getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
-    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams): Promise<TransactionSignature>;
-    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
-    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN, txParams?: TxParams): Promise<TransactionSignature>;
-    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN): Promise<TransactionInstruction>;
-    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
-    resolveSpotBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
-    getResolveSpotBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number): 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>;
+    getLiquidateSpotIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, assetMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
+    liquidateBorrowForPerpPnl(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
+    getLiquidateBorrowForPerpPnlIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, liabilityMarketIndex: number, maxLiabilityTransfer: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
+    liquidatePerpPnlForDeposit(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
+    getLiquidatePerpPnlForDepositIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, perpMarketIndex: number, assetMarketIndex: number, maxPnlTransfer: BN, limitPrice?: BN, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
+    resolvePerpBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
+    getResolvePerpBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
+    resolveSpotBankruptcy(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, txParams?: TxParams, liquidatorSubAccountId?: number): Promise<TransactionSignature>;
+    getResolveSpotBankruptcyIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, liquidatorSubAccountId?: number): Promise<TransactionInstruction>;
     updateFundingRate(perpMarketIndex: number, oracle: PublicKey, txParams?: TxParams): Promise<TransactionSignature>;
     getUpdateFundingRateIx(perpMarketIndex: number, oracle: PublicKey): Promise<TransactionInstruction>;
     updatePerpBidAskTwap(perpMarketIndex: number, makers: [PublicKey, PublicKey][], txParams?: TxParams): Promise<TransactionSignature>;