@drift-labs/sdk 2.38.1-beta.8 → 2.39.1-beta.0

package/VERSION

@@ -1 +1 @@
-2.38.1-beta.8
+2.39.1-beta.0

package/lib/adminClient.d.ts

@@ -38,6 +38,7 @@ export declare class AdminClient extends DriftClient {
     updateSpotMarketIfFactor(spotMarketIndex: number, userIfFactor: BN, totalIfFactor: BN): Promise<TransactionSignature>;
     updateSpotMarketRevenueSettlePeriod(spotMarketIndex: number, revenueSettlePeriod: BN): Promise<TransactionSignature>;
     updateSpotMarketMaxTokenDeposits(spotMarketIndex: number, maxTokenDeposits: BN): Promise<TransactionSignature>;
+    updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex: number, scaleInitialAssetWeightStart: BN): Promise<TransactionSignature>;
     updateInsuranceFundUnstakingPeriod(spotMarketIndex: number, insuranceWithdrawEscrowPeriod: BN): Promise<TransactionSignature>;
     updateLpCooldownTime(cooldownTime: BN): Promise<TransactionSignature>;
     updatePerpMarketOracle(perpMarketIndex: number, oracle: PublicKey, oracleSource: OracleSource): Promise<TransactionSignature>;

package/lib/adminClient.js

@@ -483,6 +483,17 @@ class AdminClient extends driftClient_1.DriftClient {
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         return txSig;
     }
+    async updateSpotMarketScaleInitialAssetWeightStart(spotMarketIndex, scaleInitialAssetWeightStart) {
+        const tx = this.program.transaction.updateSpotMarketScaleInitialAssetWeightStart(scaleInitialAssetWeightStart, {
+            accounts: {
+                admin: this.wallet.publicKey,
+                state: await this.getStatePublicKey(),
+                spotMarket: await (0, pda_1.getSpotMarketPublicKey)(this.program.programId, spotMarketIndex),
+            },
+        });
+        const { txSig } = await this.sendTransaction(tx, [], this.opts);
+        return txSig;
+    }
     async updateInsuranceFundUnstakingPeriod(spotMarketIndex, insuranceWithdrawEscrowPeriod) {
         const tx = await this.program.transaction.updateInsuranceFundUnstakingPeriod(insuranceWithdrawEscrowPeriod, {
             accounts: {

package/lib/driftClient.d.ts

@@ -13,7 +13,7 @@ import { DriftClientConfig } from './driftClientConfig';
 import { User } from './user';
 import { UserSubscriptionConfig } from './userConfig';
 import { UserStats } from './userStats';
-import { JupiterClient, Route, SwapMode } from './jupiter/jupiterClient';
+import { JupiterClient, QuoteResponse, Route, SwapMode } from './jupiter/jupiterClient';
 import { UserStatsSubscriptionConfig } from './userStatsConfig';
 type RemainingAccountParams = {
     userAccounts: UserAccount[];
@@ -319,7 +319,7 @@ export declare class DriftClient {
      * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
      * @param txParams
      */
-    swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }: {
+    swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, v6, }: {
         jupiterClient: JupiterClient;
         outMarketIndex: number;
         inMarketIndex: number;
@@ -331,6 +331,9 @@ export declare class DriftClient {
         route?: Route;
         reduceOnly?: SwapReduceOnly;
         txParams?: TxParams;
+        v6?: {
+            quote?: QuoteResponse;
+        };
     }): Promise<TransactionSignature>;
     getJupiterSwapIx({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, route, reduceOnly, userAccountPublicKey, }: {
         jupiterClient: JupiterClient;
@@ -349,6 +352,23 @@ export declare class DriftClient {
         ixs: TransactionInstruction[];
         lookupTables: AddressLookupTableAccount[];
     }>;
+    getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }: {
+        jupiterClient: JupiterClient;
+        outMarketIndex: number;
+        inMarketIndex: number;
+        outAssociatedTokenAccount?: PublicKey;
+        inAssociatedTokenAccount?: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+        quote?: QuoteResponse;
+        reduceOnly?: SwapReduceOnly;
+        userAccountPublicKey?: PublicKey;
+    }): Promise<{
+        ixs: TransactionInstruction[];
+        lookupTables: AddressLookupTableAccount[];
+    }>;
     /**
      * Get the drift begin_swap and end_swap instructions
      *

package/lib/driftClient.js

@@ -1975,19 +1975,41 @@ class DriftClient {
      * @param reduceOnly specify if In or Out token on the drift account must reduceOnly, checked at end of swap
      * @param txParams
      */
-    async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, }) {
-        const { ixs, lookupTables } = await this.getJupiterSwapIx({
-            jupiterClient,
-            outMarketIndex,
-            inMarketIndex,
-            outAssociatedTokenAccount,
-            inAssociatedTokenAccount,
-            amount,
-            slippageBps,
-            swapMode,
-            route,
-            reduceOnly,
-        });
+    async swap({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, route, reduceOnly, txParams, v6, }) {
+        let ixs;
+        let lookupTables;
+        if (v6) {
+            const res = await this.getJupiterSwapIxV6({
+                jupiterClient,
+                outMarketIndex,
+                inMarketIndex,
+                outAssociatedTokenAccount,
+                inAssociatedTokenAccount,
+                amount,
+                slippageBps,
+                swapMode,
+                quote: v6.quote,
+                reduceOnly,
+            });
+            ixs = res.ixs;
+            lookupTables = res.lookupTables;
+        }
+        else {
+            const res = await this.getJupiterSwapIx({
+                jupiterClient,
+                outMarketIndex,
+                inMarketIndex,
+                outAssociatedTokenAccount,
+                inAssociatedTokenAccount,
+                amount,
+                slippageBps,
+                swapMode,
+                route,
+                reduceOnly,
+            });
+            ixs = res.ixs;
+            lookupTables = res.lookupTables;
+        }
         const tx = (await this.buildTransaction(ixs, txParams, 0, lookupTables));
         const { txSig, slot } = await this.sendTransaction(tx);
         this.spotMarketLastSlotCache.set(outMarketIndex, slot);
@@ -2056,6 +2078,65 @@ class DriftClient {
         ];
         return { ixs, lookupTables };
     }
+    async getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }) {
+        const outMarket = this.getSpotMarketAccount(outMarketIndex);
+        const inMarket = this.getSpotMarketAccount(inMarketIndex);
+        if (!quote) {
+            const fetchedQuote = await jupiterClient.getQuote({
+                inputMint: inMarket.mint,
+                outputMint: outMarket.mint,
+                amount,
+                slippageBps,
+                swapMode,
+                onlyDirectRoutes,
+            });
+            quote = fetchedQuote;
+        }
+        const transaction = await jupiterClient.getSwap({
+            quote,
+            userPublicKey: this.provider.wallet.publicKey,
+            slippageBps,
+        });
+        const { transactionMessage, lookupTables } = await jupiterClient.getTransactionMessageAndLookupTables({
+            transaction,
+        });
+        const jupiterInstructions = jupiterClient.getJupiterInstructions({
+            transactionMessage,
+            inputMint: inMarket.mint,
+            outputMint: outMarket.mint,
+        });
+        const preInstructions = [];
+        if (!outAssociatedTokenAccount) {
+            outAssociatedTokenAccount = await this.getAssociatedTokenAccount(outMarket.marketIndex, false);
+            const accountInfo = await this.connection.getAccountInfo(outAssociatedTokenAccount);
+            if (!accountInfo) {
+                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(outAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, outMarket.mint));
+            }
+        }
+        if (!inAssociatedTokenAccount) {
+            inAssociatedTokenAccount = await this.getAssociatedTokenAccount(inMarket.marketIndex, false);
+            const accountInfo = await this.connection.getAccountInfo(inAssociatedTokenAccount);
+            if (!accountInfo) {
+                preInstructions.push(this.createAssociatedTokenAccountIdempotentInstruction(inAssociatedTokenAccount, this.provider.wallet.publicKey, this.provider.wallet.publicKey, inMarket.mint));
+            }
+        }
+        const { beginSwapIx, endSwapIx } = await this.getSwapIx({
+            outMarketIndex,
+            inMarketIndex,
+            amountIn: amount,
+            inTokenAccount: inAssociatedTokenAccount,
+            outTokenAccount: outAssociatedTokenAccount,
+            reduceOnly,
+            userAccountPublicKey,
+        });
+        const ixs = [
+            ...preInstructions,
+            beginSwapIx,
+            ...jupiterInstructions,
+            endSwapIx,
+        ];
+        return { ixs, lookupTables };
+    }
     /**
      * Get the drift begin_swap and end_swap instructions
      *

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.38.0",
+    "version": "2.39.0",
     "name": "drift",
     "instructions": [
         {
@@ -3538,6 +3538,32 @@
                 }
             ]
         },
+        {
+            "name": "updateSpotMarketScaleInitialAssetWeightStart",
+            "accounts": [
+                {
+                    "name": "admin",
+                    "isMut": false,
+                    "isSigner": true
+                },
+                {
+                    "name": "state",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "spotMarket",
+                    "isMut": true,
+                    "isSigner": false
+                }
+            ],
+            "args": [
+                {
+                    "name": "scaleInitialAssetWeightStart",
+                    "type": "u64"
+                }
+            ]
+        },
         {
             "name": "updateSpotMarketOracle",
             "accounts": [
@@ -5357,12 +5383,21 @@
                         ],
                         "type": "u64"
                     },
+                    {
+                        "name": "scaleInitialAssetWeightStart",
+                        "docs": [
+                            "When to begin scaling down the initial asset weight",
+                            "disabled when 0",
+                            "precision: QUOTE_PRECISION"
+                        ],
+                        "type": "u64"
+                    },
                     {
                         "name": "padding",
                         "type": {
                             "array": [
                                 "u8",
-                                56
+                                48
                             ]
                         }
                     }

package/lib/index.d.ts

@@ -4,6 +4,7 @@ import pyth from '@pythnetwork/client';
 export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
+export * from './oracles/strictOraclePrice';
 export * from './types';
 export * from './constants/perpMarkets';
 export * from './accounts/fetch';
@@ -48,6 +49,7 @@ export * from './math/repeg';
 export * from './math/margin';
 export * from './math/insurance';
 export * from './math/superStake';
+export * from './math/spotPosition';
 export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
@@ -63,6 +65,7 @@ export * from './priorityFee/priorityFeeSubscriber';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';
 export * from './util/tps';

package/lib/index.js

@@ -27,6 +27,7 @@ exports.pyth = client_1.default;
 __exportStar(require("./tokenFaucet"), exports);
 __exportStar(require("./oracles/types"), exports);
 __exportStar(require("./oracles/pythClient"), exports);
+__exportStar(require("./oracles/strictOraclePrice"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./constants/perpMarkets"), exports);
 __exportStar(require("./accounts/fetch"), exports);
@@ -71,6 +72,7 @@ __exportStar(require("./math/repeg"), exports);
 __exportStar(require("./math/margin"), exports);
 __exportStar(require("./math/insurance"), exports);
 __exportStar(require("./math/superStake"), exports);
+__exportStar(require("./math/spotPosition"), exports);
 __exportStar(require("./marinade"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);
@@ -86,6 +88,7 @@ __exportStar(require("./priorityFee/priorityFeeSubscriber"), exports);
 __exportStar(require("./phoenix/phoenixFulfillmentConfigMap"), exports);
 __exportStar(require("./tx/fastSingleTxSender"), exports);
 __exportStar(require("./tx/retryTxSender"), exports);
+__exportStar(require("./tx/priorityFeeCalculator"), exports);
 __exportStar(require("./tx/types"), exports);
 __exportStar(require("./util/computeUnits"), exports);
 __exportStar(require("./util/tps"), exports);

package/lib/math/spotBalance.d.ts

@@ -1,6 +1,7 @@
 import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
 import { BN } from '@coral-xyz/anchor';
 import { OraclePriceData } from '../oracles/types';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 /**
  * Calculates the balance of a given token amount including any accumulated interest. This
  * is the same as `SpotPosition.scaledBalance`.
@@ -33,11 +34,10 @@ export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotB
  *
  * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
  * @param {number} spotDecimals - The number of decimals in the token.
- * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
- * @param {BN} oraclePriceTwap - The Time-Weighted Average Price of the oracle.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
  * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
  */
-export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData, oraclePriceTwap: BN): BN;
+export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: number, strictOraclePrice: StrictOraclePrice): BN;
 /**
  * Calculates the value of a given token amount in relation to an oracle price data
  *
@@ -46,8 +46,9 @@ export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: numbe
  * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
  * @return {BN} The value of the token based on the oracle, scaled by `PRICE_PRECISION`
  */
-export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData): BN;
-export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: Pick<OraclePriceData, 'price'>): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateScaledInitialAssetWeight(spotMarket: SpotMarketAccount, oraclePrice: BN): BN;
 export declare function calculateLiabilityWeight(size: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
 export declare function calculateUtilization(bank: SpotMarketAccount, delta?: any): BN;
 /**

package/lib/math/spotBalance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateWithdrawLimit = exports.calculateTokenUtilizationLimits = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateWithdrawLimit = exports.calculateTokenUtilizationLimits = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateScaledInitialAssetWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@coral-xyz/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
@@ -69,20 +69,19 @@ exports.getSignedTokenAmount = getSignedTokenAmount;
  *
  * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
  * @param {number} spotDecimals - The number of decimals in the token.
- * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
- * @param {BN} oraclePriceTwap - The Time-Weighted Average Price of the oracle.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
  * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
  */
-function getStrictTokenValue(tokenAmount, spotDecimals, oraclePriceData, oraclePriceTwap) {
+function getStrictTokenValue(tokenAmount, spotDecimals, strictOraclePrice) {
     if (tokenAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    let price = oraclePriceData.price;
-    if (tokenAmount.gt(numericConstants_1.ZERO)) {
-        price = anchor_1.BN.min(oraclePriceData.price, oraclePriceTwap);
+    let price;
+    if (tokenAmount.gte(numericConstants_1.ZERO)) {
+        price = strictOraclePrice.min();
     }
     else {
-        price = anchor_1.BN.max(oraclePriceData.price, oraclePriceTwap);
+        price = strictOraclePrice.max();
     }
     const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(spotDecimals));
     return tokenAmount.mul(price).div(precisionDecrease);
@@ -104,7 +103,7 @@ function getTokenValue(tokenAmount, spotDecimals, oraclePriceData) {
     return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
 }
 exports.getTokenValue = getTokenValue;
-function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
+function calculateAssetWeight(balanceAmount, oraclePrice, spotMarket, marginCategory) {
     const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
     let sizeInAmmReservePrecision;
     if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
@@ -118,18 +117,36 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     let assetWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialAssetWeight));
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), calculateScaledInitialAssetWeight(spotMarket, oraclePrice));
             break;
         case 'Maintenance':
             assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
             break;
         default:
-            assetWeight = new anchor_1.BN(spotMarket.initialAssetWeight);
+            assetWeight = calculateScaledInitialAssetWeight(spotMarket, oraclePrice);
             break;
     }
     return assetWeight;
 }
 exports.calculateAssetWeight = calculateAssetWeight;
+function calculateScaledInitialAssetWeight(spotMarket, oraclePrice) {
+    if (spotMarket.scaleInitialAssetWeightStart.eq(numericConstants_1.ZERO)) {
+        return new anchor_1.BN(spotMarket.initialAssetWeight);
+    }
+    const deposits = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const depositsValue = getTokenValue(deposits, spotMarket.decimals, {
+        price: oraclePrice,
+    });
+    if (depositsValue.lt(spotMarket.scaleInitialAssetWeightStart)) {
+        return new anchor_1.BN(spotMarket.initialAssetWeight);
+    }
+    else {
+        return new anchor_1.BN(spotMarket.initialAssetWeight)
+            .mul(spotMarket.scaleInitialAssetWeightStart)
+            .div(depositsValue);
+    }
+}
+exports.calculateScaledInitialAssetWeight = calculateScaledInitialAssetWeight;
 function calculateLiabilityWeight(size, spotMarket, marginCategory) {
     const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
     let sizeInAmmReservePrecision;
@@ -150,7 +167,7 @@ function calculateLiabilityWeight(size, spotMarket, marginCategory) {
             liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
-            liabilityWeight = spotMarket.initialLiabilityWeight;
+            liabilityWeight = new anchor_1.BN(spotMarket.initialLiabilityWeight);
             break;
     }
     return liabilityWeight;

package/lib/math/spotMarket.d.ts

@@ -1,4 +1,4 @@
 import { BN } from '@coral-xyz/anchor';
 import { MarginCategory, SpotBalanceType, SpotMarketAccount } from '../types';
 export declare function castNumberToSpotPrecision(value: number | BN, spotMarket: SpotMarketAccount): BN;
-export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType): number;
+export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, oraclePrice: BN, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType): number;

package/lib/math/spotMarket.js

@@ -14,9 +14,9 @@ function castNumberToSpotPrecision(value, spotMarket) {
     }
 }
 exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
-function calculateSpotMarketMarginRatio(market, marginCategory, size, balanceType) {
+function calculateSpotMarketMarginRatio(market, oraclePrice, marginCategory, size, balanceType) {
     if ((0, types_1.isVariant)(balanceType, 'deposit')) {
-        const assetWeight = (0, spotBalance_1.calculateAssetWeight)(size, market, marginCategory);
+        const assetWeight = (0, spotBalance_1.calculateAssetWeight)(size, oraclePrice, market, marginCategory);
         return numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
     }
     else {

package/lib/math/spotPosition.d.ts

@@ -1,5 +1,18 @@
-import { SpotMarketAccount, SpotPosition } from '../types';
+import { MarginCategory, SpotMarketAccount, SpotPosition } from '../types';
 import { BN } from '@coral-xyz/anchor';
-import { OraclePriceData } from '../oracles/types';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
 export declare function isSpotPositionAvailable(position: SpotPosition): boolean;
-export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];
+export type OrderFillSimulation = {
+    tokenAmount: BN;
+    ordersValue: BN;
+    tokenValue: BN;
+    weight: BN;
+    weightedTokenValue: BN;
+    freeCollateralContribution: any;
+};
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, strictOraclePrice: StrictOraclePrice, marginCategory: MarginCategory): OrderFillSimulation;
+export declare function calculateWeightedTokenValue(tokenAmount: BN, tokenValue: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): {
+    weight: BN;
+    weightedTokenValue: BN;
+};
+export declare function simulateOrderFill(tokenAmount: BN, tokenValue: BN, openOrders: BN, strictOraclePrice: StrictOraclePrice, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): OrderFillSimulation;

package/lib/math/spotPosition.js

@@ -1,23 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
+exports.simulateOrderFill = exports.calculateWeightedTokenValue = exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const spotBalance_1 = require("./spotBalance");
 function isSpotPositionAvailable(position) {
     return position.scaledBalance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
 }
 exports.isSpotPositionAvailable = isSpotPositionAvailable;
-function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, strictOraclePrice, marginCategory) {
     const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
-    const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
-    const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
-    if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
-        return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+    const tokenValue = (0, spotBalance_1.getStrictTokenValue)(tokenAmount, spotMarketAccount.decimals, strictOraclePrice);
+    if (spotPosition.openBids.eq(numericConstants_1.ZERO) && spotPosition.openAsks.eq(numericConstants_1.ZERO)) {
+        const { weight, weightedTokenValue } = calculateWeightedTokenValue(tokenAmount, tokenValue, strictOraclePrice.current, spotMarketAccount, marginCategory);
+        return {
+            tokenAmount,
+            ordersValue: numericConstants_1.ZERO,
+            tokenValue,
+            weight,
+            weightedTokenValue,
+            freeCollateralContribution: weightedTokenValue,
+        };
+    }
+    const bidsSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openBids, strictOraclePrice, spotMarketAccount, marginCategory);
+    const asksSimulation = simulateOrderFill(tokenAmount, tokenValue, spotPosition.openAsks, strictOraclePrice, spotMarketAccount, marginCategory);
+    if (asksSimulation.freeCollateralContribution.lt(bidsSimulation.freeCollateralContribution)) {
+        return asksSimulation;
     }
     else {
-        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
-        return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+        return bidsSimulation;
     }
 }
 exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;
+function calculateWeightedTokenValue(tokenAmount, tokenValue, oraclePrice, spotMarket, marginCategory) {
+    let weight;
+    if (tokenValue.gte(numericConstants_1.ZERO)) {
+        weight = (0, spotBalance_1.calculateAssetWeight)(tokenAmount, oraclePrice, spotMarket, marginCategory);
+    }
+    else {
+        weight = (0, spotBalance_1.calculateLiabilityWeight)(tokenAmount.abs(), spotMarket, marginCategory);
+    }
+    return {
+        weight: weight,
+        weightedTokenValue: tokenValue
+            .mul(weight)
+            .div(numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION),
+    };
+}
+exports.calculateWeightedTokenValue = calculateWeightedTokenValue;
+function simulateOrderFill(tokenAmount, tokenValue, openOrders, strictOraclePrice, spotMarket, marginCategory) {
+    const ordersValue = (0, spotBalance_1.getTokenValue)(openOrders.neg(), spotMarket.decimals, {
+        price: strictOraclePrice.max(),
+    });
+    const tokenAmountAfterFill = tokenAmount.add(openOrders);
+    const tokenValueAfterFill = tokenValue.add(ordersValue.neg());
+    const { weight, weightedTokenValue: weightedTokenValueAfterFill } = calculateWeightedTokenValue(tokenAmountAfterFill, tokenValueAfterFill, strictOraclePrice.current, spotMarket, marginCategory);
+    const freeCollateralContribution = weightedTokenValueAfterFill.add(ordersValue);
+    return {
+        tokenAmount: tokenAmountAfterFill,
+        ordersValue: ordersValue,
+        tokenValue: tokenValueAfterFill,
+        weight,
+        weightedTokenValue: weightedTokenValueAfterFill,
+        freeCollateralContribution,
+    };
+}
+exports.simulateOrderFill = simulateOrderFill;

package/lib/oracles/strictOraclePrice.d.ts

@@ -0,0 +1,8 @@
+import { BN } from '@coral-xyz/anchor';
+export declare class StrictOraclePrice {
+    current: BN;
+    twap?: BN;
+    constructor(current: BN, twap?: BN);
+    max(): BN;
+    min(): BN;
+}

package/lib/oracles/strictOraclePrice.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrictOraclePrice = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+class StrictOraclePrice {
+    constructor(current, twap) {
+        this.current = current;
+        this.twap = twap;
+    }
+    max() {
+        return this.twap ? anchor_1.BN.max(this.twap, this.current) : this.current;
+    }
+    min() {
+        return this.twap ? anchor_1.BN.min(this.twap, this.current) : this.current;
+    }
+}
+exports.StrictOraclePrice = StrictOraclePrice;

package/lib/tx/priorityFeeCalculator.d.ts

@@ -0,0 +1,44 @@
+import { TransactionInstruction } from '@solana/web3.js';
+/**
+ * This class determines whether a priority fee needs to be included in a transaction based on
+ * a recent history of timed out transactions.
+ */
+export declare class PriorityFeeCalculator {
+    lastTxTimeoutCount: number;
+    priorityFeeTriggered: boolean;
+    lastTxTimeoutCountTriggered: number;
+    priorityFeeLatchDurationMs: number;
+    /**
+     * Constructor for the PriorityFeeCalculator class.
+     * @param currentTimeMs - The current time in milliseconds.
+     * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
+     */
+    constructor(currentTimeMs: number, priorityFeeLatchDurationMs?: number);
+    /**
+     * Update the priority fee state based on the current time and the current timeout count.
+     * @param currentTimeMs current time in milliseconds
+     * @returns true if priority fee should be included in the next transaction
+     */
+    updatePriorityFee(currentTimeMs: number, txTimeoutCount: number): boolean;
+    /**
+     * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetIxs(computeUnitLimit: number): Array<TransactionInstruction>;
+    /**
+     * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
+     * @param computeUnitLimit desired CU to use
+     * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
+     * @returns the compute unit price to use, in micro lamports
+     */
+    calculateComputeUnitPrice(computeUnitLimit: number, additionalFeeMicroLamports: number): number;
+    /**
+     * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
+     * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
+     * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered()`.
+     * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
+     * @returns An array of transaction instructions.
+     */
+    generateComputeBudgetWithPriorityFeeIx(computeUnitLimit: number, usePriorityFee: boolean, additionalFeeMicroLamports: number): Array<TransactionInstruction>;
+}