@drift-labs/sdk 2.108.0-beta.1 → 2.108.0-beta.10

package/VERSION

@@ -1 +1 @@
-2.108.0-beta.1
+2.108.0-beta.10

package/lib/browser/adminClient.d.ts

@@ -197,10 +197,8 @@ export declare class AdminClient extends DriftClient {
     getInitUserFuelIx(user: PublicKey, authority: PublicKey, fuelBonusDeposits?: number, fuelBonusBorrows?: number, fuelBonusTaker?: number, fuelBonusMaker?: number, fuelBonusInsurance?: number): Promise<TransactionInstruction>;
     initializePythPullOracle(feedId: string): Promise<TransactionSignature>;
     getInitializePythPullOracleIx(feedId: string): Promise<TransactionInstruction>;
-    initializePythLazerOracle(feedId: number, exponent: number): Promise<TransactionSignature>;
-    getInitializePythLazerOracleIx(feedId: number, exponent: number): Promise<TransactionInstruction>;
-    updatePythLazerOracleExponent(feedId: number, exponent: number): Promise<TransactionSignature>;
-    getUpdatePythLazerOracleExponentIx(feedId: number, exponent: number): Promise<TransactionInstruction>;
+    initializePythLazerOracle(feedId: number): Promise<TransactionSignature>;
+    getInitializePythLazerOracleIx(feedId: number): Promise<TransactionInstruction>;
     initializeHighLeverageModeConfig(maxUsers: number): Promise<TransactionSignature>;
     getInitializeHighLeverageModeConfigIx(maxUsers: number): Promise<TransactionInstruction>;
     updateUpdateHighLeverageModeConfig(maxUsers: number, reduceOnly: boolean): Promise<TransactionSignature>;

package/lib/browser/adminClient.js

@@ -1809,14 +1809,14 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async initializePythLazerOracle(feedId, exponent) {
-        const initializePythPullOracleIx = await this.getInitializePythLazerOracleIx(feedId, exponent);
+    async initializePythLazerOracle(feedId) {
+        const initializePythPullOracleIx = await this.getInitializePythLazerOracleIx(feedId);
         const tx = await this.buildTransaction(initializePythPullOracleIx);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async getInitializePythLazerOracleIx(feedId, exponent) {
-        return await this.program.instruction.initializePythLazerOracle(feedId, exponent, {
+    async getInitializePythLazerOracleIx(feedId) {
+        return await this.program.instruction.initializePythLazerOracle(feedId, {
             accounts: {
                 admin: this.useHotWalletAdmin
                     ? this.wallet.publicKey
@@ -1828,23 +1828,6 @@ class AdminClient extends driftClient_1.DriftClient {
             },
         });
     }
-    async updatePythLazerOracleExponent(feedId, exponent) {
-        const initializePythPullOracleIx = await this.getUpdatePythLazerOracleExponentIx(feedId, exponent);
-        const tx = await this.buildTransaction(initializePythPullOracleIx);
-        const { txSig } = await this.sendTransaction(tx, [], this.opts);
-        return txSig;
-    }
-    async getUpdatePythLazerOracleExponentIx(feedId, exponent) {
-        return await this.program.instruction.updatePythLazerOracleExponent(feedId, exponent, {
-            accounts: {
-                admin: this.useHotWalletAdmin
-                    ? this.wallet.publicKey
-                    : this.getStateAccount().admin,
-                state: await this.getStatePublicKey(),
-                lazerOracle: (0, pda_1.getPythLazerOraclePublicKey)(this.program.programId, feedId),
-            },
-        });
-    }
     async initializeHighLeverageModeConfig(maxUsers) {
         const initializeHighLeverageModeConfigIx = await this.getInitializeHighLeverageModeConfigIx(maxUsers);
         const tx = await this.buildTransaction(initializeHighLeverageModeConfigIx);

package/lib/browser/driftClient.d.ts

@@ -389,8 +389,8 @@ export declare class DriftClient {
         marketIndex?: number;
         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<{
+    placeOrders(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[]): Promise<TransactionSignature>;
+    preparePlaceOrdersTx(params: OrderParams[], txParams?: TxParams, subAccountId?: number, optionalIxs?: TransactionInstruction[]): Promise<{
         placeOrdersTx: anchor.web3.Transaction | anchor.web3.VersionedTransaction;
     }>;
     getPlaceOrdersIx(params: OptionalOrderParams[], subAccountId?: number): Promise<TransactionInstruction>;
@@ -520,7 +520,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, successCondition?: PlaceAndTakeOrderSuccessCondition, auctionDurationPercentage?: number, 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, auctionDurationPercentage?: number): Promise<{
+    preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams: OptionalOrderParams, makerInfo?: MakerInfo | MakerInfo[], referrerInfo?: ReferrerInfo, bracketOrdersParams?: OptionalOrderParams[], txParams?: TxParams, subAccountId?: number, cancelExistingOrders?: boolean, settlePnl?: boolean, exitEarlyIfSimFails?: boolean, auctionDurationPercentage?: number, optionalIxs?: TransactionInstruction[]): Promise<{
         placeAndTakeTx: Transaction | VersionedTransaction;
         cancelExistingOrdersTx: Transaction | VersionedTransaction;
         settlePnlTx: Transaction | VersionedTransaction;
@@ -706,7 +706,7 @@ export declare class DriftClient {
         settleeUserAccountPublicKey: PublicKey;
         settleeUserAccount: UserAccount;
     }[], marketIndexes: number[]): Promise<Array<TransactionInstruction>>;
-    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, txParams?: TxParams): Promise<TransactionSignature>;
+    settlePNL(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number, txParams?: TxParams, optionalIxs?: TransactionInstruction[]): Promise<TransactionSignature>;
     settlePNLIx(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndex: number): Promise<TransactionInstruction>;
     settleMultiplePNLs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams): Promise<TransactionSignature>;
     settleMultiplePNLsMultipleTxs(settleeUserAccountPublicKey: PublicKey, settleeUserAccount: UserAccount, marketIndexes: number[], mode: SettlePnlMode, txParams?: TxParams): Promise<TransactionSignature[]>;
@@ -719,13 +719,13 @@ export declare class DriftClient {
     getLiquidatePerpWithFillIx(userAccountPublicKey: PublicKey, userAccount: UserAccount, marketIndex: number, makerInfos: MakerInfo[], 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>;
-    getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, }: {
+    getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, maxAccounts, }: {
         jupiterClient: JupiterClient;
         liabilityMarketIndex: number;
         assetMarketIndex: number;
+        swapAmount: BN;
         assetTokenAccount?: PublicKey;
         liabilityTokenAccount?: PublicKey;
-        swapAmount: BN;
         slippageBps?: number;
         swapMode?: SwapMode;
         onlyDirectRoutes?: boolean;
@@ -734,6 +734,7 @@ export declare class DriftClient {
         userAccountPublicKey: PublicKey;
         userStatsAccountPublicKey: PublicKey;
         liquidatorSubAccountId?: number;
+        maxAccounts?: number;
     }): Promise<{
         ixs: TransactionInstruction[];
         lookupTables: AddressLookupTableAccount[];
@@ -895,7 +896,7 @@ export declare class DriftClient {
      * @returns
      */
     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>;
+    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean, recentBlockhash?: BlockhashWithExpiryBlockHeight, optionalIxs?: TransactionInstruction[]): Promise<Transaction | VersionedTransaction>;
     buildBulkTransactions(instructions: (TransactionInstruction | TransactionInstruction[])[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<(Transaction | 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<{

package/lib/browser/driftClient.js

@@ -2069,13 +2069,13 @@ class DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
-    async placeOrders(params, txParams, subAccountId) {
-        const { txSig } = await this.sendTransaction((await this.preparePlaceOrdersTx(params, txParams, subAccountId))
-            .placeOrdersTx, [], this.opts, false);
+    async placeOrders(params, txParams, subAccountId, optionalIxs) {
+        const { txSig } = await this.sendTransaction((await this.preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs)).placeOrdersTx, [], this.opts, false);
         return txSig;
     }
-    async preparePlaceOrdersTx(params, txParams, subAccountId) {
-        const tx = await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams);
+    async preparePlaceOrdersTx(params, txParams, subAccountId, optionalIxs) {
+        const lookupTableAccount = await this.fetchMarketLookupTableAccount();
+        const tx = await this.buildTransaction(await this.getPlaceOrdersIx(params, subAccountId), txParams, undefined, [lookupTableAccount], undefined, undefined, optionalIxs);
         return {
             placeOrdersTx: tx,
         };
@@ -2989,7 +2989,7 @@ class DriftClient {
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
         return txSig;
     }
-    async preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails, auctionDurationPercentage) {
+    async preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails, auctionDurationPercentage, optionalIxs) {
         const placeAndTakeIxs = [];
         const txsToSign = {
             placeAndTakeTx: undefined,
@@ -2998,6 +2998,7 @@ class DriftClient {
         };
         // 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();
+        const lookupTableAccount = await this.fetchMarketLookupTableAccount();
         let earlyExitFailedPlaceAndTakeSim = false;
         const prepPlaceAndTakeTx = async () => {
             var _a;
@@ -3014,7 +3015,7 @@ class DriftClient {
                 useSimulatedComputeUnits: false,
             };
             if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
-                const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, true, recentBlockHash));
+                const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParams, undefined, [lookupTableAccount], true, recentBlockHash, optionalIxs));
                 const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2, txParams.lowerBoundCu);
                 if (shouldExitIfSimulationFails && !simulationResult.success) {
                     earlyExitFailedPlaceAndTakeSim = true;
@@ -3023,17 +3024,17 @@ class DriftClient {
                 txsToSign.placeAndTakeTx = await this.buildTransaction(placeAndTakeIxs, {
                     ...txParamsWithoutImplicitSimulation,
                     computeUnits: simulationResult.computeUnits,
-                }, undefined, undefined, undefined, recentBlockHash);
+                }, undefined, [lookupTableAccount], undefined, recentBlockHash, optionalIxs);
             }
             else {
-                txsToSign.placeAndTakeTx = await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, undefined, recentBlockHash);
+                txsToSign.placeAndTakeTx = await this.buildTransaction(placeAndTakeIxs, txParams, undefined, [lookupTableAccount], undefined, recentBlockHash, optionalIxs);
             }
             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.cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion, undefined, undefined, recentBlockHash);
+                txsToSign.cancelExistingOrdersTx = await this.buildTransaction([cancelOrdersIx], txParams, this.txVersion, [lookupTableAccount], undefined, recentBlockHash, optionalIxs);
             }
             return;
         };
@@ -3041,7 +3042,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.settlePnlTx = await this.buildTransaction([settlePnlIx], txParams, this.txVersion, undefined, undefined, recentBlockHash);
+                txsToSign.settlePnlTx = await this.buildTransaction([settlePnlIx], txParams, this.txVersion, [lookupTableAccount], undefined, recentBlockHash, optionalIxs);
             }
             return;
         };
@@ -3186,7 +3187,7 @@ class DriftClient {
      * Borsh encode swift taker order params
      */
     encodeSwiftOrderParamsMessage(orderParamsMessage) {
-        const anchorIxName = 'global' + ':' + 'swiftOrderMessageParams';
+        const anchorIxName = 'global' + ':' + 'SwiftOrderParamsMessage';
         const prefix = Buffer.from((0, sha256_1.sha256)(anchorIxName).slice(0, 8));
         const buf = Buffer.concat([
             prefix,
@@ -3647,8 +3648,9 @@ class DriftClient {
         }
         return ixs;
     }
-    async settlePNL(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, txParams) {
-        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex), txParams), [], this.opts);
+    async settlePNL(settleeUserAccountPublicKey, settleeUserAccount, marketIndex, txParams, optionalIxs) {
+        const lookupTableAccount = await this.fetchMarketLookupTableAccount();
+        const { txSig } = await this.sendTransaction(await this.buildTransaction(await this.settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex), txParams, undefined, [lookupTableAccount], undefined, undefined, optionalIxs), [], this.opts);
         return txSig;
     }
     async settlePNLIx(settleeUserAccountPublicKey, settleeUserAccount, marketIndex) {
@@ -3829,7 +3831,7 @@ class DriftClient {
             remainingAccounts: remainingAccounts,
         });
     }
-    async getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, }) {
+    async getJupiterLiquidateSpotWithSwapIxV6({ jupiterClient, liabilityMarketIndex, assetMarketIndex, swapAmount, assetTokenAccount, liabilityTokenAccount, slippageBps, swapMode, onlyDirectRoutes, quote, userAccount, userAccountPublicKey, userStatsAccountPublicKey, liquidatorSubAccountId, maxAccounts, }) {
         const liabilityMarket = this.getSpotMarketAccount(liabilityMarketIndex);
         const assetMarket = this.getSpotMarketAccount(assetMarketIndex);
         if (!quote) {
@@ -3840,6 +3842,7 @@ class DriftClient {
                 slippageBps,
                 swapMode,
                 onlyDirectRoutes,
+                maxAccounts,
             });
             quote = fetchedQuote;
         }
@@ -4893,7 +4896,7 @@ class DriftClient {
             return this.txSender.send(tx, additionalSigners, opts !== null && opts !== void 0 ? opts : this.opts, preSigned);
         }
     }
-    async buildTransaction(instructions, txParams, txVersion, lookupTables, forceVersionedTransaction, recentBlockhash) {
+    async buildTransaction(instructions, txParams, txVersion, lookupTables, forceVersionedTransaction, recentBlockhash, optionalIxs) {
         return this.txHandler.buildTransaction({
             instructions,
             txVersion: txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion,
@@ -4904,6 +4907,7 @@ class DriftClient {
             lookupTables,
             forceVersionedTransaction,
             recentBlockhash,
+            optionalIxs,
         });
     }
     async buildBulkTransactions(instructions, txParams, txVersion, lookupTables, forceVersionedTransaction) {

package/lib/browser/idl/drift.json

@@ -6667,40 +6667,6 @@
                 {
                     "name": "feedId",
                     "type": "u32"
-                },
-                {
-                    "name": "exponent",
-                    "type": "i32"
-                }
-            ]
-        },
-        {
-            "name": "updatePythLazerOracleExponent",
-            "accounts": [
-                {
-                    "name": "admin",
-                    "isMut": true,
-                    "isSigner": true
-                },
-                {
-                    "name": "lazerOracle",
-                    "isMut": true,
-                    "isSigner": false
-                },
-                {
-                    "name": "state",
-                    "isMut": false,
-                    "isSigner": false
-                }
-            ],
-            "args": [
-                {
-                    "name": "feedId",
-                    "type": "u32"
-                },
-                {
-                    "name": "exponent",
-                    "type": "i32"
                 }
             ]
         },
@@ -11393,7 +11359,8 @@
                         "name": "Match",
                         "fields": [
                             "publicKey",
-                            "u16"
+                            "u16",
+                            "u64"
                         ]
                     }
                 ]
@@ -14675,6 +14642,11 @@
             "code": 6308,
             "name": "InvalidLiquidateSpotWithSwap",
             "msg": "InvalidLiquidateSpotWithSwap"
+        },
+        {
+            "code": 6309,
+            "name": "SwiftUserContextUserMismatch",
+            "msg": "User in swift message does not match user in ix context"
         }
     ],
     "metadata": {

package/lib/browser/index.d.ts

@@ -86,6 +86,7 @@ export * from './oracles/pythClient';
 export * from './oracles/pythPullClient';
 export * from './oracles/pythLazerClient';
 export * from './oracles/switchboardOnDemandClient';
+export * from './oracles/oracleId';
 export * from './swift/swiftOrderSubscriber';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';

package/lib/browser/index.js

@@ -109,6 +109,7 @@ __exportStar(require("./oracles/pythClient"), exports);
 __exportStar(require("./oracles/pythPullClient"), exports);
 __exportStar(require("./oracles/pythLazerClient"), exports);
 __exportStar(require("./oracles/switchboardOnDemandClient"), exports);
+__exportStar(require("./oracles/oracleId"), exports);
 __exportStar(require("./swift/swiftOrderSubscriber"), exports);
 __exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);

package/lib/browser/math/liquidation.d.ts

@@ -1,4 +1,7 @@
 /// <reference types="bn.js" />
 import { BN } from '@coral-xyz/anchor';
 export declare function calculateBaseAssetAmountToCoverMarginShortage(marginShortage: BN, marginRatio: number, liquidationFee: number, ifLiquidationFee: number, oraclePrice: BN, quoteOraclePrice: BN): BN | undefined;
+export declare function calculateLiabilityTransferToCoverMarginShortage(marginShortage: BN, assetWeight: number, assetLiquidationMultiplier: number, liabilityWeight: number, liabilityLiquidationMultiplier: number, liabilityDecimals: number, liabilityPrice: BN, ifLiquidationFee: number): BN | undefined;
+export declare function calculateAssetTransferForLiabilityTransfer(assetAmount: BN, assetLiquidationMultiplier: number, assetDecimals: number, assetPrice: BN, liabilityAmount: BN, liabilityLiquidationMultiplier: number, liabilityDecimals: number, liabilityPrice: BN): BN | undefined;
 export declare function calculateMaxPctToLiquidate(userLastActiveSlot: BN, userLiquidationMarginFreed: BN, marginShortage: BN, slot: BN, initialPctToLiquidate: BN, liquidationDuration: BN): BN;
+export declare function getMarginShortage(maintenanceMarginRequirementPlusBuffer: BN, maintenanceTotalCollateral: BN): BN;

package/lib/browser/math/liquidation.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxPctToLiquidate = exports.calculateBaseAssetAmountToCoverMarginShortage = void 0;
+exports.getMarginShortage = exports.calculateMaxPctToLiquidate = exports.calculateAssetTransferForLiabilityTransfer = exports.calculateLiabilityTransferToCoverMarginShortage = exports.calculateBaseAssetAmountToCoverMarginShortage = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 function calculateBaseAssetAmountToCoverMarginShortage(marginShortage, marginRatio, liquidationFee, ifLiquidationFee, oraclePrice, quoteOraclePrice) {
@@ -20,6 +20,88 @@ function calculateBaseAssetAmountToCoverMarginShortage(marginShortage, marginRat
         .sub(oraclePrice.mul(new anchor_1.BN(ifLiquidationFee)).div(numericConstants_1.LIQUIDATION_FEE_PRECISION)));
 }
 exports.calculateBaseAssetAmountToCoverMarginShortage = calculateBaseAssetAmountToCoverMarginShortage;
+function calculateLiabilityTransferToCoverMarginShortage(marginShortage, assetWeight, assetLiquidationMultiplier, liabilityWeight, liabilityLiquidationMultiplier, liabilityDecimals, liabilityPrice, ifLiquidationFee) {
+    if (assetWeight >= liabilityWeight) {
+        // undefined is max
+        return undefined;
+    }
+    let numeratorScale;
+    let denominatorScale;
+    if (liabilityDecimals > 6) {
+        numeratorScale = new anchor_1.BN(10).pow(new anchor_1.BN(liabilityDecimals - 6));
+        denominatorScale = new anchor_1.BN(1);
+    }
+    else {
+        numeratorScale = new anchor_1.BN(1);
+        denominatorScale = new anchor_1.BN(10).pow(new anchor_1.BN(6 - liabilityDecimals));
+    }
+    // multiply market weights by extra 10 to increase precision
+    const liabilityWeightComponent = liabilityWeight * 10;
+    const assetWeightComponent = (assetWeight * 10 * assetLiquidationMultiplier) /
+        liabilityLiquidationMultiplier;
+    if (assetWeightComponent >= liabilityWeightComponent) {
+        return undefined;
+    }
+    return anchor_1.BN.max(marginShortage
+        .mul(numeratorScale)
+        .mul(numericConstants_1.PRICE_PRECISION.mul(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION).mul(numericConstants_1.TEN))
+        .div(liabilityPrice
+        .mul(new anchor_1.BN(liabilityWeightComponent).sub(new anchor_1.BN(assetWeightComponent)))
+        .sub(liabilityPrice
+        .mul(new anchor_1.BN(ifLiquidationFee))
+        .div(numericConstants_1.LIQUIDATION_FEE_PRECISION)
+        .mul(new anchor_1.BN(liabilityWeight))
+        .mul(new anchor_1.BN(10))))
+        .div(denominatorScale), numericConstants_1.ONE);
+}
+exports.calculateLiabilityTransferToCoverMarginShortage = calculateLiabilityTransferToCoverMarginShortage;
+function calculateAssetTransferForLiabilityTransfer(assetAmount, assetLiquidationMultiplier, assetDecimals, assetPrice, liabilityAmount, liabilityLiquidationMultiplier, liabilityDecimals, liabilityPrice) {
+    let numeratorScale;
+    let denominatorScale;
+    if (assetDecimals > liabilityDecimals) {
+        numeratorScale = new anchor_1.BN(10).pow(new anchor_1.BN(assetDecimals - liabilityDecimals));
+        denominatorScale = new anchor_1.BN(1);
+    }
+    else {
+        numeratorScale = new anchor_1.BN(1);
+        denominatorScale = new anchor_1.BN(10).pow(new anchor_1.BN(liabilityDecimals - assetDecimals));
+    }
+    let assetTransfer = liabilityAmount
+        .mul(numeratorScale)
+        .mul(liabilityPrice)
+        .mul(new anchor_1.BN(assetLiquidationMultiplier))
+        .div(assetPrice.mul(new anchor_1.BN(liabilityLiquidationMultiplier)))
+        .div(denominatorScale);
+    assetTransfer = anchor_1.BN.max(assetTransfer, numericConstants_1.ONE);
+    // Need to check if asset_transfer should be rounded to asset amount
+    let assetValueNumeratorScale;
+    let assetValueDenominatorScale;
+    if (assetDecimals > 6) {
+        assetValueNumeratorScale = new anchor_1.BN(10).pow(new anchor_1.BN(assetDecimals - 6));
+        assetValueDenominatorScale = new anchor_1.BN(1);
+    }
+    else {
+        assetValueNumeratorScale = new anchor_1.BN(1);
+        assetValueDenominatorScale = new anchor_1.BN(10).pow(new anchor_1.BN(6 - assetDecimals));
+    }
+    let assetDelta;
+    if (assetTransfer > assetAmount) {
+        assetDelta = assetTransfer.sub(assetAmount);
+    }
+    else {
+        assetDelta = assetAmount.sub(assetTransfer);
+    }
+    const assetValueDelta = assetDelta
+        .mul(assetPrice)
+        .div(numericConstants_1.PRICE_PRECISION)
+        .mul(assetValueNumeratorScale)
+        .div(assetValueDenominatorScale);
+    if (assetValueDelta.lt(numericConstants_1.QUOTE_PRECISION)) {
+        assetTransfer = assetAmount;
+    }
+    return assetTransfer;
+}
+exports.calculateAssetTransferForLiabilityTransfer = calculateAssetTransferForLiabilityTransfer;
 function calculateMaxPctToLiquidate(userLastActiveSlot, userLiquidationMarginFreed, marginShortage, slot, initialPctToLiquidate, liquidationDuration) {
     // if margin shortage is tiny, accelerate liquidation
     if (marginShortage.lt(new anchor_1.BN(50).mul(numericConstants_1.QUOTE_PRECISION))) {
@@ -44,3 +126,9 @@ function calculateMaxPctToLiquidate(userLastActiveSlot, userLiquidationMarginFre
     return marginFreeable.mul(numericConstants_1.LIQUIDATION_PCT_PRECISION).div(marginShortage);
 }
 exports.calculateMaxPctToLiquidate = calculateMaxPctToLiquidate;
+function getMarginShortage(maintenanceMarginRequirementPlusBuffer, maintenanceTotalCollateral) {
+    return maintenanceMarginRequirementPlusBuffer
+        .sub(maintenanceTotalCollateral)
+        .abs();
+}
+exports.getMarginShortage = getMarginShortage;

package/lib/browser/math/oracles.js

@@ -149,6 +149,22 @@ function getMultipleBetweenOracleSources(firstOracleSource, secondOracleSource)
         (0, types_1.isVariant)(secondOracleSource, 'pythPull')) {
         return { numerator: new index_1.BN(1), denominator: new index_1.BN(1000) };
     }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer1M')) {
+        return { numerator: new index_1.BN(1000000), denominator: new index_1.BN(1) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer1K')) {
+        return { numerator: new index_1.BN(1000), denominator: new index_1.BN(1) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer1M') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer')) {
+        return { numerator: new index_1.BN(1), denominator: new index_1.BN(1000000) };
+    }
+    if ((0, types_1.isVariant)(firstOracleSource, 'pythLazer1K') &&
+        (0, types_1.isVariant)(secondOracleSource, 'pythLazer')) {
+        return { numerator: new index_1.BN(1), denominator: new index_1.BN(1000) };
+    }
     return { numerator: new index_1.BN(1), denominator: new index_1.BN(1) };
 }
 exports.getMultipleBetweenOracleSources = getMultipleBetweenOracleSources;

package/lib/browser/oracles/oracleId.js

@@ -29,6 +29,10 @@ function getOracleSourceNum(source) {
         return types_1.OracleSourceNum.SWITCHBOARD_ON_DEMAND;
     if ('pythLazer' in source)
         return types_1.OracleSourceNum.PYTH_LAZER;
+    if ('pythLazer1K' in source)
+        return types_1.OracleSourceNum.PYTH_LAZER_1K;
+    if ('pythLazer1M' in source)
+        return types_1.OracleSourceNum.PYTH_LAZER_1M;
     throw new Error('Invalid oracle source');
 }
 exports.getOracleSourceNum = getOracleSourceNum;

package/lib/browser/swift/swiftOrderSubscriber.js

@@ -72,7 +72,7 @@ class SwiftOrderSubscriber {
                 if (message['order']) {
                     const order = JSON.parse(message['order']);
                     const swiftOrderParamsBuf = Buffer.from(order['order_message'], 'hex');
-                    const swiftOrderParamsMessage = this.driftClient.program.coder.types.decode('SwiftOrderParamsMessage', swiftOrderParamsBuf);
+                    const swiftOrderParamsMessage = this.driftClient.decodeSwiftOrderParamsMessage(swiftOrderParamsBuf);
                     if (!swiftOrderParamsMessage.swiftOrderParams.price) {
                         console.error(`order has no price: ${JSON.stringify(swiftOrderParamsMessage.swiftOrderParams)}`);
                         return;

package/lib/browser/tx/txHandler.d.ts

@@ -12,6 +12,7 @@ export type TxBuildingProps = {
     txParams?: TxParams;
     recentBlockhash?: BlockhashWithExpiryBlockHeight;
     wallet?: IWallet;
+    optionalIxs?: TransactionInstruction[];
 };
 export type TxHandlerConfig = {
     blockhashCachingEnabled?: boolean;

package/lib/browser/tx/txHandler.js

@@ -277,24 +277,35 @@ class TxHandler {
      */
     async buildTransaction(props) {
         var _a;
-        const { instructions, txVersion, txParams, connection: _connection, preFlightCommitment: _preFlightCommitment, fetchMarketLookupTableAccount, forceVersionedTransaction, } = props;
+        const { txVersion, txParams, connection: _connection, preFlightCommitment: _preFlightCommitment, fetchMarketLookupTableAccount, forceVersionedTransaction, instructions, } = props;
         let { lookupTables } = props;
         // # Collect and process Tx Params
         let baseTxParams = {
             computeUnits: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits,
             computeUnitsPrice: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice,
         };
+        const instructionsArray = Array.isArray(instructions)
+            ? instructions
+            : [instructions];
+        let instructionsToUse;
+        // add optional ixs if there's room (usually oracle cranks)
+        if (props.optionalIxs && txVersion === 0) {
+            instructionsToUse = (0, utils_1.getCombinedInstructions)(instructionsArray, props.optionalIxs, txVersion === 0, lookupTables);
+        }
+        else {
+            instructionsToUse = instructionsArray;
+        }
         if (txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits) {
-            const processedTxParams = await this.getProcessedTransactionParams(props);
+            const processedTxParams = await this.getProcessedTransactionParams({
+                ...props,
+                instructions: instructionsToUse,
+            });
             baseTxParams = {
                 ...baseTxParams,
                 ...processedTxParams,
             };
         }
-        const instructionsArray = Array.isArray(instructions)
-            ? instructions
-            : [instructions];
-        const { hasSetComputeUnitLimitIx, hasSetComputeUnitPriceIx } = (0, computeUnits_1.containsComputeUnitIxs)(instructionsArray);
+        const { hasSetComputeUnitLimitIx, hasSetComputeUnitPriceIx } = (0, computeUnits_1.containsComputeUnitIxs)(instructionsToUse);
         // # Create Tx Instructions
         const allIx = [];
         const computeUnits = baseTxParams === null || baseTxParams === void 0 ? void 0 : baseTxParams.computeUnits;
@@ -314,7 +325,7 @@ class TxHandler {
                 microLamports: computeUnitsPrice,
             }));
         }
-        allIx.push(...instructionsArray);
+        allIx.push(...instructionsToUse);
         const recentBlockhash = (_a = props === null || props === void 0 ? void 0 : props.recentBlockhash) !== null && _a !== void 0 ? _a : (await this.getLatestBlockhashForTransaction());
         // # Create and return Transaction
         if (txVersion === 'legacy') {

package/lib/browser/tx/utils.d.ts

@@ -1,2 +1,4 @@
-import { Transaction, VersionedTransaction } from '@solana/web3.js';
+import { AddressLookupTableAccount, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 export declare const isVersionedTransaction: (tx: Transaction | VersionedTransaction) => boolean;
+export declare const getSizeOfTransaction: (instructions: TransactionInstruction[], versionedTransaction?: boolean, addressLookupTables?: AddressLookupTableAccount[]) => number;
+export declare const getCombinedInstructions: (baseInstructions: TransactionInstruction[], optionalInstructions?: TransactionInstruction[], versionedTransaction?: boolean, addressLookupTables?: AddressLookupTableAccount[]) => TransactionInstruction[];