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

package/lib/jupiter/jupiterClient.d.ts

@@ -28,6 +28,173 @@ export interface Route {
     slippageBps: number;
     swapMode: SwapMode;
 }
+/**
+ *
+ * @export
+ * @interface RoutePlanStep
+ */
+export interface RoutePlanStep {
+    /**
+     *
+     * @type {SwapInfo}
+     * @memberof RoutePlanStep
+     */
+    swapInfo: SwapInfo;
+    /**
+     *
+     * @type {number}
+     * @memberof RoutePlanStep
+     */
+    percent: number;
+}
+export interface SwapInfo {
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    ammKey: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    label?: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    inputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    outputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    inAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    outAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    feeAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof SwapInfo
+     */
+    feeMint: string;
+}
+/**
+ *
+ * @export
+ * @interface PlatformFee
+ */
+export interface PlatformFee {
+    /**
+     *
+     * @type {string}
+     * @memberof PlatformFee
+     */
+    amount?: string;
+    /**
+     *
+     * @type {number}
+     * @memberof PlatformFee
+     */
+    feeBps?: number;
+}
+/**
+ *
+ * @export
+ * @interface QuoteResponse
+ */
+export interface QuoteResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    inputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    inAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    outputMint: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    outAmount: string;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    otherAmountThreshold: string;
+    /**
+     *
+     * @type {SwapMode}
+     * @memberof QuoteResponse
+     */
+    swapMode: SwapMode;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    slippageBps: number;
+    /**
+     *
+     * @type {PlatformFee}
+     * @memberof QuoteResponse
+     */
+    platformFee?: PlatformFee;
+    /**
+     *
+     * @type {string}
+     * @memberof QuoteResponse
+     */
+    priceImpactPct: string;
+    /**
+     *
+     * @type {Array<RoutePlanStep>}
+     * @memberof QuoteResponse
+     */
+    routePlan: Array<RoutePlanStep>;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    contextSlot?: number;
+    /**
+     *
+     * @type {number}
+     * @memberof QuoteResponse
+     */
+    timeTaken?: number;
+}
 export declare class JupiterClient {
     url: string;
     connection: Connection;
@@ -36,6 +203,7 @@ export declare class JupiterClient {
         connection: Connection;
     });
     /**
+     * ** @deprecated - use getQuote
      * Get routes for a swap
      * @param inputMint the mint of the input token
      * @param outputMint the mint of the output token
@@ -53,6 +221,35 @@ export declare class JupiterClient {
         onlyDirectRoutes?: boolean;
     }): Promise<Route[]>;
     /**
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    getQuote({ inputMint, outputMint, amount, slippageBps, swapMode, onlyDirectRoutes, }: {
+        inputMint: PublicKey;
+        outputMint: PublicKey;
+        amount: BN;
+        slippageBps?: number;
+        swapMode?: SwapMode;
+        onlyDirectRoutes?: boolean;
+    }): Promise<QuoteResponse>;
+    /**
+     * Get a swap transaction for quote
+     * @param quoteResponse quote to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    getSwap({ quote, userPublicKey, slippageBps, }: {
+        quote: QuoteResponse;
+        userPublicKey: PublicKey;
+        slippageBps?: number;
+    }): Promise<VersionedTransaction>;
+    /**
+     * ** @deprecated - use getSwap
      * Get a swap transaction for a route
      * @param route the route to perform swap
      * @param userPublicKey the signer's wallet public key

package/lib/jupiter/jupiterClient.js

@@ -8,11 +8,12 @@ const web3_js_1 = require("@solana/web3.js");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 class JupiterClient {
     constructor({ connection }) {
-        this.url = 'https://quote-api.jup.ag/v4';
+        this.url = 'https://quote-api.jup.ag';
         this.lookupTableCahce = new Map();
         this.connection = connection;
     }
     /**
+     * ** @deprecated - use getQuote
      * Get routes for a swap
      * @param inputMint the mint of the input token
      * @param outputMint the mint of the output token
@@ -30,17 +31,61 @@ class JupiterClient {
             swapMode,
             onlyDirectRoutes: onlyDirectRoutes.toString(),
         }).toString();
-        const { data: routes } = await (await (0, node_fetch_1.default)(`https://quote-api.jup.ag/v4/quote?${params}`)).json();
+        const { data: routes } = await (await (0, node_fetch_1.default)(`${this.url}/v4/quote?${params}`)).json();
         return routes;
     }
     /**
+     * Get routes for a swap
+     * @param inputMint the mint of the input token
+     * @param outputMint the mint of the output token
+     * @param amount the amount of the input token
+     * @param slippageBps the slippage tolerance in basis points
+     * @param swapMode the swap mode (ExactIn or ExactOut)
+     * @param onlyDirectRoutes whether to only return direct routes
+     */
+    async getQuote({ inputMint, outputMint, amount, slippageBps = 50, swapMode = 'ExactIn', onlyDirectRoutes = false, }) {
+        const params = new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            slippageBps: slippageBps.toString(),
+            swapMode,
+            onlyDirectRoutes: onlyDirectRoutes.toString(),
+        }).toString();
+        const quote = await (await (0, node_fetch_1.default)(`${this.url}/v6/quote?${params}`)).json();
+        return quote;
+    }
+    /**
+     * Get a swap transaction for quote
+     * @param quoteResponse quote to perform swap
+     * @param userPublicKey the signer's wallet public key
+     * @param slippageBps the slippage tolerance in basis points
+     */
+    async getSwap({ quote, userPublicKey, slippageBps = 50, }) {
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}/v6/swap`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                quoteResponse: quote,
+                userPublicKey,
+                slippageBps,
+            }),
+        })).json();
+        const { swapTransaction } = resp;
+        const swapTransactionBuf = Buffer.from(swapTransaction, 'base64');
+        return web3_js_1.VersionedTransaction.deserialize(swapTransactionBuf);
+    }
+    /**
+     * ** @deprecated - use getSwap
      * Get a swap transaction for a route
      * @param route the route to perform swap
      * @param userPublicKey the signer's wallet public key
      * @param slippageBps the slippage tolerance in basis points
      */
     async getSwapTransaction({ route, userPublicKey, slippageBps = 50, }) {
-        const resp = await (await (0, node_fetch_1.default)(`${this.url}/swap`, {
+        const resp = await (await (0, node_fetch_1.default)(`${this.url}/v4/swap`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

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/priorityFee/priorityFeeSubscriber.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Connection, PublicKey } from '@solana/web3.js';
+export declare class PriorityFeeSubscriber {
+    connection: Connection;
+    frequencyMs: number;
+    addresses: PublicKey[];
+    slotsToCheck: number;
+    intervalId?: NodeJS.Timer;
+    latestPriorityFee: number;
+    avgPriorityFee: number;
+    maxPriorityFee: number;
+    lastSlotSeen: number;
+    constructor({ connection, frequencyMs, addresses, slotsToCheck, }: {
+        connection: Connection;
+        frequencyMs: number;
+        addresses: PublicKey[];
+        slotsToCheck?: number;
+    });
+    subscribe(): Promise<void>;
+    load(): Promise<void>;
+    unsubscribe(): Promise<void>;
+}

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityFeeSubscriber = void 0;
+class PriorityFeeSubscriber {
+    constructor({ connection, frequencyMs, addresses, slotsToCheck = 10, }) {
+        this.latestPriorityFee = 0;
+        // avg of last {slotsToCheck} slots
+        this.avgPriorityFee = 0;
+        // max of last {slotsToCheck} slots
+        this.maxPriorityFee = 0;
+        this.lastSlotSeen = 0;
+        this.connection = connection;
+        this.frequencyMs = frequencyMs;
+        this.addresses = addresses;
+        this.slotsToCheck = slotsToCheck;
+    }
+    async subscribe() {
+        if (this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(this.load.bind(this), this.frequencyMs);
+    }
+    async load() {
+        var _a, _b, _c;
+        // @ts-ignore
+        const rpcJSONResponse = await this.connection._rpcRequest('getRecentPrioritizationFees', [this.addresses]);
+        const descResults = (_c = (_b = (_a = rpcJSONResponse === null || rpcJSONResponse === void 0 ? void 0 : rpcJSONResponse.result) === null || _a === void 0 ? void 0 : _a.sort((a, b) => b.slot - a.slot)) === null || _b === void 0 ? void 0 : _b.slice(0, this.slotsToCheck)) !== null && _c !== void 0 ? _c : [];
+        if (!(descResults === null || descResults === void 0 ? void 0 : descResults.length))
+            return;
+        const mostRecentResult = descResults[0];
+        this.latestPriorityFee = mostRecentResult.prioritizationFee;
+        this.lastSlotSeen = mostRecentResult.slot;
+        this.avgPriorityFee =
+            descResults.reduce((a, b) => {
+                return a + b.prioritizationFee;
+            }, 0) / descResults.length;
+        this.maxPriorityFee = Math.max(...descResults.map((result) => result.prioritizationFee));
+    }
+    async unsubscribe() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+    }
+}
+exports.PriorityFeeSubscriber = PriorityFeeSubscriber;

package/lib/tokenFaucet.js

@@ -37,6 +37,7 @@ class TokenFaucet {
         this.connection = connection;
         this.wallet = wallet;
         this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
+        // @ts-ignore
         const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
         this.provider = provider;
         this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);

package/lib/types.d.ts

@@ -242,6 +242,9 @@ export declare class OrderActionExplanation {
     static readonly ORDER_FILLED_WITH_SERUM: {
         orderFillWithSerum: {};
     };
+    static readonly ORDER_FILLED_WITH_PHOENIX: {
+        orderFillWithPhoenix: {};
+    };
     static readonly REDUCE_ONLY_ORDER_INCREASED_POSITION: {
         reduceOnlyOrderIncreasedPosition: {};
     };
@@ -721,6 +724,7 @@ export type SpotMarketAccount = {
     maintenanceLiabilityWeight: number;
     liquidatorFee: number;
     imfFactor: number;
+    scaleInitialAssetWeightStart: BN;
     withdrawGuardThreshold: BN;
     depositTokenTwap: BN;
     borrowTokenTwap: BN;