@drift-labs/sdk 2.15.0-beta.0 → 2.16.0-beta.0

package/lib/constants/perpMarkets.js

@@ -76,6 +76,16 @@ exports.MainnetPerpMarkets = [
         launchTs: 1670347281000,
         oracleSource: __1.OracleSource.PYTH,
     },
+    {
+        fullName: 'Aptos',
+        category: ['L1', 'Infra'],
+        symbol: 'APT-PERP',
+        baseAssetSymbol: 'APT',
+        marketIndex: 3,
+        oracle: new web3_js_1.PublicKey('FNNvb1AFDnDVPkocEri8mWbJ1952HQZtFLuwPiUjSJQ'),
+        launchTs: 1675802661000,
+        oracleSource: __1.OracleSource.PYTH,
+    },
 ];
 exports.PerpMarkets = {
     devnet: exports.DevnetPerpMarkets,

package/lib/events/fetchLogs.js

@@ -20,11 +20,11 @@ async function fetchLogs(connection, programId, finality, beforeTx, untilTx, lim
         return undefined;
     }
     const chunkedSignatures = chunk(filteredSignatures, 100);
+    const config = { commitment: finality, maxSupportedTransactionVersion: 0 };
     const transactionLogs = (await Promise.all(chunkedSignatures.map(async (chunk) => {
-        const transactions = await connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), {
-            commitment: finality,
-            maxSupportedTransactionVersion: 0,
-        });
+        const transactions = await connection.getTransactions(chunk.map((confirmedSignature) => confirmedSignature.signature), 
+        //@ts-ignore
+        config);
         return transactions.reduce((logs, transaction) => {
             if (transaction) {
                 logs.push(mapTransactionResponseToLog(transaction));

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.15.0-0",
+    "version": "2.16.0-beta.0",
     "name": "drift",
     "instructions": [
         {

package/lib/math/market.d.ts

@@ -30,6 +30,7 @@ export declare function calculateOracleSpread(price: BN, oraclePriceData: Oracle
 export declare function calculateMarketMarginRatio(market: PerpMarketAccount, size: BN, marginCategory: MarginCategory): number;
 export declare function calculateUnrealizedAssetWeight(market: PerpMarketAccount, quoteSpotMarket: SpotMarketAccount, unrealizedPnl: BN, marginCategory: MarginCategory, oraclePriceData: OraclePriceData): BN;
 export declare function calculateMarketAvailablePNL(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
+export declare function calculateMarketMaxAvailableInsurance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount): BN;
 export declare function calculateNetUserPnl(perpMarket: PerpMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateNetUserPnlImbalance(perpMarket: PerpMarketAccount, spotMarket: SpotMarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateAvailablePerpLiquidity(market: PerpMarketAccount, oraclePriceData: OraclePriceData, dlob: DLOB, slot: number): {

package/lib/math/market.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAvailablePerpLiquidity = exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateOracleReserveSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
+exports.calculateAvailablePerpLiquidity = exports.calculateNetUserPnlImbalance = exports.calculateNetUserPnl = exports.calculateMarketMaxAvailableInsurance = exports.calculateMarketAvailablePNL = exports.calculateUnrealizedAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateOracleReserveSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateReservePrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
 const margin_1 = require("./margin");
 const numericConstants_1 = require("../constants/numericConstants");
 const spotBalance_1 = require("./spotBalance");
+const assert_1 = require("../assert/assert");
 /**
  * Calculates market mark price
  *
@@ -62,12 +63,14 @@ exports.calculateOracleSpread = calculateOracleSpread;
 function calculateMarketMarginRatio(market, size, marginCategory) {
     let marginRatio;
     switch (marginCategory) {
-        case 'Initial':
+        case 'Initial': {
             marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
-        case 'Maintenance':
+        }
+        case 'Maintenance': {
             marginRatio = margin_1.calculateSizePremiumLiabilityWeight(size, new anchor_1.BN(market.imfFactor), new anchor_1.BN(market.marginRatioMaintenance), numericConstants_1.MARGIN_PRECISION).toNumber();
             break;
+        }
     }
     return marginRatio;
 }
@@ -98,6 +101,14 @@ function calculateMarketAvailablePNL(perpMarket, spotMarket) {
     return spotBalance_1.getTokenAmount(perpMarket.pnlPool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
 }
 exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;
+function calculateMarketMaxAvailableInsurance(perpMarket, spotMarket) {
+    assert_1.assert(spotMarket.marketIndex == numericConstants_1.QUOTE_SPOT_MARKET_INDEX);
+    // todo: insuranceFundAllocation technically not guaranteed to be in Insurance Fund
+    const insuranceFundAllocation = perpMarket.insuranceClaim.quoteMaxInsurance.sub(perpMarket.insuranceClaim.quoteSettledInsurance);
+    const ammFeePool = spotBalance_1.getTokenAmount(perpMarket.amm.feePool.scaledBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    return insuranceFundAllocation.add(ammFeePool);
+}
+exports.calculateMarketMaxAvailableInsurance = calculateMarketMaxAvailableInsurance;
 function calculateNetUserPnl(perpMarket, oraclePriceData) {
     const netUserPositionValue = perpMarket.amm.baseAssetAmountWithAmm
         .mul(oraclePriceData.price)

package/lib/math/spotBalance.d.ts

@@ -8,7 +8,7 @@ export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotB
 export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData, oraclePriceTwap: BN): BN;
 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 calculateLiabilityWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(size: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
 export declare function calculateUtilization(bank: SpotMarketAccount): BN;
 export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
 export declare function calculateDepositRate(bank: SpotMarketAccount): BN;

package/lib/math/spotBalance.js

@@ -84,30 +84,30 @@ function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
     return assetWeight;
 }
 exports.calculateAssetWeight = calculateAssetWeight;
-function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
+function calculateLiabilityWeight(size, spotMarket, marginCategory) {
     const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
     let sizeInAmmReservePrecision;
     if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
-        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+        sizeInAmmReservePrecision = size.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
     }
     else {
-        sizeInAmmReservePrecision = balanceAmount
+        sizeInAmmReservePrecision = size
             .mul(numericConstants_1.AMM_RESERVE_PRECISION)
             .div(sizePrecision);
     }
-    let assetWeight;
+    let liabilityWeight;
     switch (marginCategory) {
         case 'Initial':
-            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         case 'Maintenance':
-            assetWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            liabilityWeight = margin_1.calculateSizePremiumLiabilityWeight(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
             break;
         default:
-            assetWeight = spotMarket.initialLiabilityWeight;
+            liabilityWeight = spotMarket.initialLiabilityWeight;
             break;
     }
-    return assetWeight;
+    return liabilityWeight;
 }
 exports.calculateLiabilityWeight = calculateLiabilityWeight;
 function calculateUtilization(bank) {

package/lib/math/spotMarket.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { SpotMarketAccount } from '../types';
+import { MarginCategory, SpotBalanceType, SpotMarketAccount } from '../types';
 export declare function castNumberToSpotPrecision(value: number, spotMarket: SpotMarketAccount): BN;
+export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType): number;

package/lib/math/spotMarket.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.castNumberToSpotPrecision = void 0;
+exports.calculateSpotMarketMarginRatio = exports.castNumberToSpotPrecision = void 0;
 const anchor_1 = require("@project-serum/anchor");
+const types_1 = require("../types");
+const spotBalance_1 = require("./spotBalance");
+const numericConstants_1 = require("../constants/numericConstants");
 function castNumberToSpotPrecision(value, spotMarket) {
     return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
 }
 exports.castNumberToSpotPrecision = castNumberToSpotPrecision;
+function calculateSpotMarketMarginRatio(market, marginCategory, size, balanceType) {
+    if (types_1.isVariant(balanceType, 'deposit')) {
+        const assetWeight = spotBalance_1.calculateAssetWeight(size, market, marginCategory);
+        return numericConstants_1.MARGIN_PRECISION.sub(assetWeight).toNumber();
+    }
+    else {
+        const liabilityWeight = spotBalance_1.calculateLiabilityWeight(size, market, marginCategory);
+        return liabilityWeight.sub(numericConstants_1.MARGIN_PRECISION).toNumber();
+    }
+}
+exports.calculateSpotMarketMarginRatio = calculateSpotMarketMarginRatio;

package/lib/math/spotPosition.js

@@ -11,12 +11,12 @@ function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceDa
     const tokenAmount = spotBalance_1.getSignedTokenAmount(spotBalance_1.getTokenAmount(spotPosition.scaledBalance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
     const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
     const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
-    if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+    if (tokenAmountAllBidsFill.abs().gt(tokenAmountAllAsksFill.abs())) {
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
     }
     else {
-        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        const worstCaseQuoteTokenAmount = spotBalance_1.getTokenValue(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
         return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
     }
 }

package/lib/user.d.ts

@@ -6,7 +6,7 @@ import StrictEventEmitter from 'strict-event-emitter-types';
 import { DriftClient } from './driftClient';
 import { MarginCategory, Order, UserAccount, PerpPosition, SpotPosition, PerpMarketAccount } from './types';
 import { UserAccountSubscriber, UserAccountEvents, DataAndSlot } from './accounts/types';
-import { PositionDirection, BN, SpotMarketAccount } from '.';
+import { PositionDirection, BN, SpotMarketAccount, MarketType } from '.';
 import { OraclePriceData } from './oracles/types';
 import { UserConfig } from './userConfig';
 export declare class User {
@@ -80,8 +80,8 @@ export declare class User {
      * calculates Buying Power = free collateral / initial margin ratio
      * @returns : Precision QUOTE_PRECISION
      */
-    getBuyingPower(marketIndex: number): BN;
-    getBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex: number, freeCollateral: BN, baseAssetAmount: BN): BN;
+    getPerpBuyingPower(marketIndex: number): BN;
+    getPerpBuyingPowerFromFreeCollateralAndBaseAssetAmount(marketIndex: number, freeCollateral: BN, baseAssetAmount: BN): BN;
     /**
      * calculates Free Collateral = Total collateral - initial margin requirement
      * @returns : Precision QUOTE_PRECISION
@@ -110,10 +110,16 @@ export declare class User {
      * @returns : Precision QUOTE_PRECISION
      */
     getUnrealizedFundingPNL(marketIndex?: number): BN;
+    getSpotMarketAssetAndLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): {
+        totalAssetValue: BN;
+        totalLiabilityValue: BN;
+    };
     getSpotMarketLiabilityValue(marketIndex?: number, marginCategory?: MarginCategory, liquidationBuffer?: BN, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     getSpotLiabilityValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, liquidationBuffer?: BN, strict?: boolean, now?: BN): BN;
     getSpotMarketAssetValue(marketIndex?: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     getSpotAssetValue(tokenAmount: BN, oraclePriceData: OraclePriceData, spotMarketAccount: SpotMarketAccount, marginCategory?: MarginCategory, strict?: boolean, now?: BN): BN;
+    getSpotTokenAmount(marketIndex: number): BN;
+    getSpotPositionValue(marketIndex: number, marginCategory?: MarginCategory, includeOpenOrders?: boolean, strict?: boolean, now?: BN): BN;
     getNetSpotMarketValue(withWeightMarginCategory?: MarginCategory): BN;
     /**
      * calculates TotalCollateral: collateral + unrealized pnl
@@ -146,6 +152,12 @@ export declare class User {
      * @returns : Precision TEN_THOUSAND
      */
     getLeverage(): BN;
+    getLeverageComponents(): {
+        perpLiabilityValue: BN;
+        perpPnl: BN;
+        spotAssetValue: BN;
+        spotLiabilityValue: BN;
+    };
     getTotalLiabilityValue(marginCategory?: MarginCategory): BN;
     getTotalAssetValue(marginCategory?: MarginCategory): BN;
     /**
@@ -153,12 +165,19 @@ export declare class User {
      * @params category {Initial, Maintenance}
      * @returns : Precision TEN_THOUSAND
      */
-    getMaxLeverage(marketIndex: number, category?: MarginCategory): BN;
+    getMaxLeverageForPerp(perpMarketIndex: number, category?: MarginCategory): BN;
     /**
-     * calculates margin ratio: total collateral / |total position value|
+     * calculates max allowable leverage exceeding hitting requirement category
+     * @param spotMarketIndex
+     * @param direction
      * @returns : Precision TEN_THOUSAND
      */
-    getMarginRatio(marginCategory?: MarginCategory): BN;
+    getMaxLeverageForSpot(spotMarketIndex: number, direction: PositionDirection): BN;
+    /**
+     * calculates margin ratio: 1 / leverage
+     * @returns : Precision TEN_THOUSAND
+     */
+    getMarginRatio(): BN;
     canBeLiquidated(): boolean;
     isBeingLiquidated(): boolean;
     isBankrupt(): boolean;
@@ -172,7 +191,7 @@ export declare class User {
      * @param marketIndex
      * @returns Precision : PRICE_PRECISION
      */
-    spotLiquidationPrice(marketIndex: number): BN;
+    spotLiquidationPrice(marketIndex: number, positionBaseSizeChange?: BN): BN;
     /**
      * Calculate the liquidation price of a perp position, with optional parameter to calculate the liquidation price after a trade
      * @param marketIndex
@@ -210,15 +229,27 @@ export declare class User {
      * @param tradeSide
      * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
      */
-    getMaxTradeSizeUSDC(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    getMaxTradeSizeUSDCForPerp(targetMarketIndex: number, tradeSide: PositionDirection): BN;
+    /**
+     * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
+     *
+     * @param targetMarketIndex
+     * @param direction
+     * @param currentQuoteAssetValue
+     * @param currentSpotMarketNetValue
+     * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
+     */
+    getMaxTradeSizeUSDCForSpot(targetMarketIndex: number, direction: PositionDirection, currentQuoteAssetValue?: BN, currentSpotMarketNetValue?: BN): BN;
     /**
      * Returns the leverage ratio for the account after adding (or subtracting) the given quote size to the given position
      * @param targetMarketIndex
-     * @param positionMarketIndex
+     * @param: targetMarketType
      * @param tradeQuoteAmount
+     * @param tradeSide
+     * @param includeOpenOrders
      * @returns leverageRatio : Precision TEN_THOUSAND
      */
-    accountLeverageRatioAfterTrade(targetMarketIndex: number, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
+    accountLeverageRatioAfterTrade(targetMarketIndex: number, targetMarketType: MarketType, tradeQuoteAmount: BN, tradeSide: PositionDirection, includeOpenOrders?: boolean): BN;
     /**
      * Calculates how much fee will be taken for a given sized trade
      * @param quoteAmount