@drift-labs/sdk 0.2.0-master.1 → 0.2.0-master.12

package/lib/idl/{mock_usdc_faucet.json → token_faucet.json}

@@ -1,23 +1,23 @@
 {
-    "version": "0.0.0",
-    "name": "mock_usdc_faucet",
+    "version": "0.1.0",
+    "name": "token_faucet",
     "instructions": [
         {
             "name": "initialize",
             "accounts": [
                 {
-                    "name": "mockUsdcFaucetState",
+                    "name": "faucetConfig",
                     "isMut": true,
                     "isSigner": false
                 },
                 {
                     "name": "admin",
-                    "isMut": false,
+                    "isMut": true,
                     "isSigner": true
                 },
                 {
                     "name": "mintAccount",
-                    "isMut": false,
+                    "isMut": true,
                     "isSigner": false
                 },
                 {
@@ -29,20 +29,20 @@
                     "name": "systemProgram",
                     "isMut": false,
                     "isSigner": false
-                }
-            ],
-            "args": [
+                },
                 {
-                    "name": "mockUsdcFaucetNonce",
-                    "type": "u8"
+                    "name": "tokenProgram",
+                    "isMut": false,
+                    "isSigner": false
                 }
-            ]
+            ],
+            "args": []
         },
         {
             "name": "mintToUser",
             "accounts": [
                 {
-                    "name": "mockUsdcFaucetState",
+                    "name": "faucetConfig",
                     "isMut": false,
                     "isSigner": false
                 },
@@ -73,11 +73,42 @@
                     "type": "u64"
                 }
             ]
+        },
+        {
+            "name": "transferMintAuthority",
+            "accounts": [
+                {
+                    "name": "faucetConfig",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "admin",
+                    "isMut": true,
+                    "isSigner": true
+                },
+                {
+                    "name": "mintAccount",
+                    "isMut": true,
+                    "isSigner": false
+                },
+                {
+                    "name": "mintAuthority",
+                    "isMut": false,
+                    "isSigner": false
+                },
+                {
+                    "name": "tokenProgram",
+                    "isMut": false,
+                    "isSigner": false
+                }
+            ],
+            "args": []
         }
     ],
     "accounts": [
         {
-            "name": "MockUSDCFaucetState",
+            "name": "FaucetConfig",
             "type": {
                 "kind": "struct",
                 "fields": [
@@ -103,17 +134,9 @@
     ],
     "errors": [
         {
-            "code": 300,
+            "code": 6000,
             "name": "InvalidMintAccountAuthority",
             "msg": "Program not mint authority"
-        },
-        {
-            "code": 301,
-            "name": "Unauthorized",
-            "msg": "Signer must be MockUSDCFaucet admin"
         }
-    ],
-    "metadata": {
-        "address": "2z2DLVD3tBWc86pbvvy5qN31v1NXprM6zA5MDr2FMx64"
-    }
+    ]
 }

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
-export * from './mockUSDCFaucet';
+import pyth from '@pythnetwork/client';
+export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
@@ -33,6 +34,7 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
+export * from './math/margin';
 export * from './orders';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
@@ -47,4 +49,4 @@ export * from './util/tps';
 export * from './math/bankBalance';
 export * from './constants/banks';
 export * from './clearingHouseConfig';
-export { BN, PublicKey };
+export { BN, PublicKey, pyth };

package/lib/index.js

@@ -13,13 +13,18 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PublicKey = exports.BN = void 0;
+exports.pyth = exports.PublicKey = exports.BN = void 0;
 const anchor_1 = require("@project-serum/anchor");
 Object.defineProperty(exports, "BN", { enumerable: true, get: function () { return anchor_1.BN; } });
 const web3_js_1 = require("@solana/web3.js");
 Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return web3_js_1.PublicKey; } });
-__exportStar(require("./mockUSDCFaucet"), exports);
+const client_1 = __importDefault(require("@pythnetwork/client"));
+exports.pyth = client_1.default;
+__exportStar(require("./tokenFaucet"), exports);
 __exportStar(require("./oracles/types"), exports);
 __exportStar(require("./oracles/pythClient"), exports);
 __exportStar(require("./oracles/switchboardClient"), exports);
@@ -52,6 +57,7 @@ __exportStar(require("./math/amm"), exports);
 __exportStar(require("./math/trade"), exports);
 __exportStar(require("./math/orders"), exports);
 __exportStar(require("./math/repeg"), exports);
+__exportStar(require("./math/margin"), exports);
 __exportStar(require("./orders"), exports);
 __exportStar(require("./orderParams"), exports);
 __exportStar(require("./slot/SlotSubscriber"), exports);

package/lib/math/amm.d.ts

@@ -2,6 +2,8 @@
 import { BN } from '@project-serum/anchor';
 import { AMM, PositionDirection, SwapDirection, MarketAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
+export declare function calculatePegFromTargetPrice(targetPrice: BN, baseAssetReserve: BN, quoteAssetReserve: BN): BN;
+export declare function calculateOptimalPegAndBudget(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN, BN, boolean];
 export declare function calculateNewAmm(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN, BN, BN];
 export declare function calculateUpdatedAMM(amm: AMM, oraclePriceData: OraclePriceData): AMM;
 export declare function calculateUpdatedAMMSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
@@ -10,7 +12,7 @@ export declare function calculateUpdatedAMMSpreadReserves(amm: AMM, direction: P
     sqrtK: BN;
     newPeg: BN;
 };
-export declare function calculateBidAskPrice(amm: AMM, oraclePriceData: OraclePriceData): [BN, BN];
+export declare function calculateBidAskPrice(amm: AMM, oraclePriceData: OraclePriceData, withUpdate?: boolean): [BN, BN];
 /**
  * Calculates a price given an arbitrary base and quote amount (they must have the same precision)
  *
@@ -31,6 +33,9 @@ export declare type AssetType = 'quote' | 'base';
  * @returns quoteAssetReserve and baseAssetReserve after swap. : Precision AMM_RESERVE_PRECISION
  */
 export declare function calculateAmmReservesAfterSwap(amm: Pick<AMM, 'pegMultiplier' | 'quoteAssetReserve' | 'sqrtK' | 'baseAssetReserve'>, inputAssetType: AssetType, swapAmount: BN, swapDirection: SwapDirection): [BN, BN];
+export declare function calculateEffectiveLeverage(baseSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, markPrice: BN, totalFeeMinusDistributions: BN): number;
+export declare function calculateMaxSpread(marginRatioInitial: number): number;
+export declare function calculateSpreadBN(baseSpread: number, lastOracleMarkSpreadPct: BN, lastOracleConfPct: BN, maxSpread: number, quoteAssetReserve: BN, terminalQuoteAssetReserve: BN, pegMultiplier: BN, netBaseAssetAmount: BN, markPrice: BN, totalFeeMinusDistributions: BN): [number, number];
 export declare function calculateSpread(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): number;
 export declare function calculateSpreadReserves(amm: AMM, direction: PositionDirection, oraclePriceData: OraclePriceData): {
     baseAssetReserve: BN;

package/lib/math/amm.js

@@ -1,25 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = void 0;
+exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 const __1 = require("..");
 const repeg_1 = require("./repeg");
-function calculateNewAmm(amm, oraclePriceData) {
-    let pKNumer = new anchor_1.BN(1);
-    let pKDenom = new anchor_1.BN(1);
+function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
+    return targetPrice
+        .mul(baseAssetReserve)
+        .div(quoteAssetReserve)
+        .add(numericConstants_1.PRICE_DIV_PEG.div(new anchor_1.BN(2)))
+        .div(numericConstants_1.PRICE_DIV_PEG);
+}
+exports.calculatePegFromTargetPrice = calculatePegFromTargetPrice;
+function calculateOptimalPegAndBudget(amm, oraclePriceData) {
+    const markPriceBefore = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     const targetPrice = oraclePriceData.price;
-    let newPeg = targetPrice
-        .mul(amm.baseAssetReserve)
-        .div(amm.quoteAssetReserve)
-        .add(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION).div(new anchor_1.BN(2)))
-        .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.PEG_PRECISION));
-    let prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
+    const newPeg = calculatePegFromTargetPrice(targetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+    const prePegCost = (0, repeg_1.calculateRepegCost)(amm, newPeg);
     const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
     const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
-    if (prePegCost.gt(budget)) {
+    if (budget.lt(prePegCost)) {
+        const maxPriceSpread = new anchor_1.BN(amm.maxSpread)
+            .mul(targetPrice)
+            .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
+        let newTargetPrice;
+        let newOptimalPeg;
+        let newBudget;
+        const targetPriceGap = markPriceBefore.sub(targetPrice);
+        if (targetPriceGap.abs().gt(maxPriceSpread)) {
+            const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
+            if (targetPriceGap.lt(new anchor_1.BN(0))) {
+                newTargetPrice = markPriceBefore.add(markAdj);
+            }
+            else {
+                newTargetPrice = markPriceBefore.sub(markAdj);
+            }
+            newOptimalPeg = calculatePegFromTargetPrice(newTargetPrice, amm.baseAssetReserve, amm.quoteAssetReserve);
+            newBudget = (0, repeg_1.calculateRepegCost)(amm, newOptimalPeg);
+            return [newTargetPrice, newOptimalPeg, newBudget, false];
+        }
+    }
+    return [targetPrice, newPeg, budget, true];
+}
+exports.calculateOptimalPegAndBudget = calculateOptimalPegAndBudget;
+function calculateNewAmm(amm, oraclePriceData) {
+    let pKNumer = new anchor_1.BN(1);
+    let pKDenom = new anchor_1.BN(1);
+    const [targetPrice, _newPeg, budget, checkLowerBound] = calculateOptimalPegAndBudget(amm, oraclePriceData);
+    let prePegCost = (0, repeg_1.calculateRepegCost)(amm, _newPeg);
+    let newPeg = _newPeg;
+    if (prePegCost.gt(budget) && checkLowerBound) {
         [pKNumer, pKDenom] = [new anchor_1.BN(999), new anchor_1.BN(1000)];
         const deficitMadeup = (0, repeg_1.calculateAdjustKCost)(amm, pKNumer, pKDenom);
         (0, assert_1.assert)(deficitMadeup.lte(new anchor_1.BN(0)));
@@ -73,8 +106,14 @@ function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
     return result;
 }
 exports.calculateUpdatedAMMSpreadReserves = calculateUpdatedAMMSpreadReserves;
-function calculateBidAskPrice(amm, oraclePriceData) {
-    const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+function calculateBidAskPrice(amm, oraclePriceData, withUpdate = true) {
+    let newAmm;
+    if (withUpdate) {
+        newAmm = calculateUpdatedAMM(amm, oraclePriceData);
+    }
+    else {
+        newAmm = amm;
+    }
     const askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
     const bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
     const askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
@@ -126,44 +165,88 @@ function calculateAmmReservesAfterSwap(amm, inputAssetType, swapAmount, swapDire
     return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
+function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+    // inventory skew
+    const netBaseAssetValue = quoteAssetReserve
+        .sub(terminalQuoteAssetReserve)
+        .mul(pegMultiplier)
+        .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+    const localBaseAssetValue = netBaseAssetAmount
+        .mul(markPrice)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+    const effectiveLeverage = localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
+        (Math.max(0, totalFeeMinusDistributions.toNumber()) + 1) +
+        1 / numericConstants_1.QUOTE_PRECISION.toNumber();
+    return effectiveLeverage;
+}
+exports.calculateEffectiveLeverage = calculateEffectiveLeverage;
+function calculateMaxSpread(marginRatioInitial) {
+    const maxTargetSpread = new anchor_1.BN(marginRatioInitial)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(numericConstants_1.MARGIN_PRECISION))
+        .toNumber();
+    return maxTargetSpread;
+}
+exports.calculateMaxSpread = calculateMaxSpread;
+function calculateSpreadBN(baseSpread, lastOracleMarkSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions) {
+    let longSpread = baseSpread / 2;
+    let shortSpread = baseSpread / 2;
+    if (lastOracleMarkSpreadPct.gt(numericConstants_1.ZERO)) {
+        shortSpread = Math.max(shortSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    }
+    else if (lastOracleMarkSpreadPct.lt(numericConstants_1.ZERO)) {
+        longSpread = Math.max(longSpread, lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber());
+    }
+    const maxTargetSpread = maxSpread;
+    const MAX_INVENTORY_SKEW = 5;
+    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, markPrice, totalFeeMinusDistributions);
+    if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
+        const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+            longSpread *= spreadScale;
+        }
+        else {
+            shortSpread *= spreadScale;
+        }
+    }
+    else {
+        longSpread *= MAX_INVENTORY_SKEW;
+        shortSpread *= MAX_INVENTORY_SKEW;
+    }
+    const totalSpread = longSpread + shortSpread;
+    if (totalSpread > maxTargetSpread) {
+        if (longSpread > shortSpread) {
+            longSpread = Math.min(longSpread, maxTargetSpread);
+            shortSpread = maxTargetSpread - longSpread;
+        }
+        else {
+            shortSpread = Math.min(shortSpread, maxTargetSpread);
+            longSpread = maxTargetSpread - shortSpread;
+        }
+    }
+    return [longSpread, shortSpread];
+}
+exports.calculateSpreadBN = calculateSpreadBN;
 function calculateSpread(amm, direction, oraclePriceData) {
-    let spread = amm.baseSpread / 2;
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-        return spread;
+        return amm.baseSpread / 2;
     }
     const markPrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || markPrice;
+    const confInterval = oraclePriceData.confidence || numericConstants_1.ZERO;
     const targetMarkSpreadPct = markPrice
         .sub(targetPrice)
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(markPrice);
-    // oracle retreat
-    if (((0, types_1.isVariant)(direction, 'long') && targetMarkSpreadPct.lt(numericConstants_1.ZERO)) ||
-        ((0, types_1.isVariant)(direction, 'short') && targetMarkSpreadPct.gt(numericConstants_1.ZERO))) {
-        spread = Math.max(spread, targetMarkSpreadPct.abs().toNumber());
+    const confIntervalPct = confInterval
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(markPrice);
+    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.netBaseAssetAmount, markPrice, amm.totalFeeMinusDistributions);
+    let spread;
+    if ((0, types_1.isVariant)(direction, 'long')) {
+        spread = longSpread;
     }
-    // inventory skew
-    const MAX_INVENTORY_SKEW = 5;
-    if ((amm.netBaseAssetAmount.gt(numericConstants_1.ZERO) && (0, types_1.isVariant)(direction, 'long')) ||
-        (amm.netBaseAssetAmount.lt(numericConstants_1.ZERO) && (0, types_1.isVariant)(direction, 'short')) ||
-        amm.totalFeeMinusDistributions.eq(numericConstants_1.ZERO)) {
-        const netCostBasis = amm.quoteAssetAmountLong.sub(amm.quoteAssetAmountShort);
-        const netBaseAssetValue = amm.quoteAssetReserve
-            .sub(amm.terminalQuoteAssetReserve)
-            .mul(amm.pegMultiplier)
-            .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-        const localBaseAssetValue = amm.netBaseAssetAmount
-            .mul(markPrice)
-            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
-        const netPnl = netBaseAssetValue.sub(netCostBasis);
-        const localPnl = localBaseAssetValue.sub(netCostBasis);
-        let effectiveLeverage = MAX_INVENTORY_SKEW;
-        if (amm.totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
-            effectiveLeverage =
-                localPnl.sub(netPnl).toNumber() /
-                    amm.totalFeeMinusDistributions.toNumber();
-        }
-        spread *= Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+    else {
+        spread = shortSpread;
     }
     return spread;
 }

package/lib/math/auction.js

@@ -4,7 +4,10 @@ exports.getAuctionPrice = exports.isAuctionComplete = void 0;
 const types_1 = require("../types");
 const _1 = require("../.");
 function isAuctionComplete(order, slot) {
-    return new _1.BN(slot).sub(order.slot).gte(new _1.BN(order.auctionDuration));
+    if (order.auctionDuration === 0) {
+        return true;
+    }
+    return new _1.BN(slot).sub(order.slot).gt(new _1.BN(order.auctionDuration));
 }
 exports.isAuctionComplete = isAuctionComplete;
 function getAuctionPrice(order, slot) {

package/lib/math/bankBalance.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="bn.js" />
-import { BankAccount, BankBalanceType } from '../types';
+import { BankAccount, BankBalanceType, MarginCategory } from '../types';
 import { BN } from '@project-serum/anchor';
 export declare function getBalance(tokenAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
 export declare function getTokenAmount(balanceAmount: BN, bank: BankAccount, balanceType: BankBalanceType): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, bank: BankAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, bank: BankAccount, marginCategory: MarginCategory): BN;
 export declare function calculateInterestAccumulated(bank: BankAccount, now: BN): {
     borrowInterest: BN;
     depositInterest: BN;

package/lib/math/bankBalance.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateInterestAccumulated = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenAmount = exports.getBalance = void 0;
 const types_1 = require("../types");
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
+const margin_1 = require("./margin");
 function getBalance(tokenAmount, bank, balanceType) {
     const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
     const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
@@ -24,6 +25,58 @@ function getTokenAmount(balanceAmount, bank, balanceType) {
     return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 exports.getTokenAmount = getTokenAmount;
+function calculateAssetWeight(balanceAmount, bank, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(bank.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.initialAssetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.maintenanceAssetWeight);
+            break;
+        default:
+            assetWeight = bank.initialAssetWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateLiabilityWeight(balanceAmount, bank, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(bank.decimals));
+    let sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.initialLiabilityWeight, numericConstants_1.BANK_WEIGHT_PRECISION);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, bank.imfFactor, bank.maintenanceLiabilityWeight, numericConstants_1.BANK_WEIGHT_PRECISION);
+            break;
+        default:
+            assetWeight = bank.initialLiabilityWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
 function calculateInterestAccumulated(bank, now) {
     const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
     const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);

package/lib/math/margin.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, UserPosition } from '..';
+export declare function calculateSizePremiumLiabilityWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, liabilityWeight: BN, precision: BN): BN;
+export declare function calculateSizeDiscountAssetWeight(size: BN, // AMM_RESERVE_PRECISION
+imfFactor: BN, assetWeight: BN): BN;
+export declare function calculateOraclePriceForPerpMargin(marketPosition: UserPosition, market: MarketAccount, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarginBaseAssetValue(market: MarketAccount, marketPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateWorstCaseBaseAssetAmount(marketPosition: UserPosition): BN;

package/lib/math/margin.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWorstCaseBaseAssetAmount = exports.calculateMarginBaseAssetValue = exports.calculateOraclePriceForPerpMargin = exports.calculateSizeDiscountAssetWeight = exports.calculateSizePremiumLiabilityWeight = void 0;
+const utils_1 = require("./utils");
+const numericConstants_1 = require("../constants/numericConstants");
+const anchor_1 = require("@project-serum/anchor");
+function calculateSizePremiumLiabilityWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, liabilityWeight, precision) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return liabilityWeight;
+    }
+    const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    const liabilityWeightNumerator = liabilityWeight.sub(liabilityWeight.div(anchor_1.BN.max(new anchor_1.BN(1), numericConstants_1.BANK_IMF_PRECISION.div(imfFactor))));
+    const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(new anchor_1.BN(100000).mul(numericConstants_1.BANK_IMF_PRECISION).div(precision)) // 1e5
+    );
+    const maxLiabilityWeight = anchor_1.BN.max(liabilityWeight, sizePremiumLiabilityWeight);
+    return maxLiabilityWeight;
+}
+exports.calculateSizePremiumLiabilityWeight = calculateSizePremiumLiabilityWeight;
+function calculateSizeDiscountAssetWeight(size, // AMM_RESERVE_PRECISION
+imfFactor, assetWeight) {
+    if (imfFactor.eq(numericConstants_1.ZERO)) {
+        return assetWeight;
+    }
+    const sizeSqrt = (0, utils_1.squareRootBN)(size.div(new anchor_1.BN(1000)).add(new anchor_1.BN(1))); //1e13 -> 1e10 -> 1e5
+    const imfNumerator = numericConstants_1.BANK_IMF_PRECISION.add(numericConstants_1.BANK_IMF_PRECISION.div(new anchor_1.BN(10)));
+    const sizeDiscountAssetWeight = imfNumerator.mul(numericConstants_1.BANK_WEIGHT_PRECISION).div(numericConstants_1.BANK_IMF_PRECISION.add(sizeSqrt // 1e5
+        .mul(imfFactor)
+        .div(new anchor_1.BN(100000)) // 1e5
+    ));
+    const minAssetWeight = anchor_1.BN.min(assetWeight, sizeDiscountAssetWeight);
+    return minAssetWeight;
+}
+exports.calculateSizeDiscountAssetWeight = calculateSizeDiscountAssetWeight;
+function calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData) {
+    const oraclePriceOffset = anchor_1.BN.min(new anchor_1.BN(market.amm.maxSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION), oraclePriceData.confidence.add(new anchor_1.BN(market.amm.baseSpread)
+        .mul(oraclePriceData.price)
+        .div(numericConstants_1.BID_ASK_SPREAD_PRECISION)));
+    let marginPrice;
+    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+    }
+    else {
+        marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+    }
+    return marginPrice;
+}
+exports.calculateOraclePriceForPerpMargin = calculateOraclePriceForPerpMargin;
+function calculateMarginBaseAssetValue(market, marketPosition, oraclePriceData) {
+    const marginPrice = calculateOraclePriceForPerpMargin(marketPosition, market, oraclePriceData);
+    const baseAssetValue = marketPosition.baseAssetAmount
+        .abs()
+        .mul(marginPrice)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO.mul(numericConstants_1.MARK_PRICE_PRECISION));
+    return baseAssetValue;
+}
+exports.calculateMarginBaseAssetValue = calculateMarginBaseAssetValue;
+function calculateWorstCaseBaseAssetAmount(marketPosition) {
+    const allBids = marketPosition.baseAssetAmount.add(marketPosition.openBids);
+    const allAsks = marketPosition.baseAssetAmount.add(marketPosition.openAsks);
+    if (allBids.abs().gt(allAsks.abs())) {
+        return allBids;
+    }
+    else {
+        return allAsks;
+    }
+}
+exports.calculateWorstCaseBaseAssetAmount = calculateWorstCaseBaseAssetAmount;

package/lib/math/market.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="bn.js" />
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, MarginCategory, BankAccount } from '../types';
 import { OraclePriceData } from '../oracles/types';
 /**
  * Calculates market mark price
@@ -26,3 +26,6 @@ export declare function calculateAskPrice(market: MarketAccount, oraclePriceData
 export declare function calculateNewMarketAfterTrade(baseAssetAmount: BN, direction: PositionDirection, market: MarketAccount): MarketAccount;
 export declare function calculateMarkOracleSpread(market: MarketAccount, oraclePriceData: OraclePriceData): BN;
 export declare function calculateOracleSpread(price: BN, oraclePriceData: OraclePriceData): BN;
+export declare function calculateMarketMarginRatio(market: MarketAccount, size: BN, marginCategory: MarginCategory): number;
+export declare function calculateUnsettledAssetWeight(market: MarketAccount, unsettledPnl: BN, marginCategory: MarginCategory): BN;
+export declare function calculateMarketAvailablePNL(market: MarketAccount, bank: BankAccount): BN;

package/lib/math/market.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+exports.calculateMarketAvailablePNL = exports.calculateUnsettledAssetWeight = exports.calculateMarketMarginRatio = exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = 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 bankBalance_1 = require("./bankBalance");
 /**
  * Calculates market mark price
  *
@@ -55,3 +59,33 @@ function calculateOracleSpread(price, oraclePriceData) {
     return price.sub(oraclePriceData.price);
 }
 exports.calculateOracleSpread = calculateOracleSpread;
+function calculateMarketMarginRatio(market, size, marginCategory) {
+    let marginRatio;
+    switch (marginCategory) {
+        case 'Initial':
+            marginRatio = (0, margin_1.calculateSizePremiumLiabilityWeight)(size, market.imfFactor, new anchor_1.BN(market.marginRatioInitial), numericConstants_1.MARGIN_PRECISION).toNumber();
+            break;
+        case 'Maintenance':
+            marginRatio = market.marginRatioMaintenance;
+            break;
+    }
+    return marginRatio;
+}
+exports.calculateMarketMarginRatio = calculateMarketMarginRatio;
+function calculateUnsettledAssetWeight(market, unsettledPnl, marginCategory) {
+    let assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(unsettledPnl, market.unsettledImfFactor, new anchor_1.BN(market.unsettledInitialAssetWeight));
+            break;
+        case 'Maintenance':
+            assetWeight = new anchor_1.BN(market.unsettledMaintenanceAssetWeight);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateUnsettledAssetWeight = calculateUnsettledAssetWeight;
+function calculateMarketAvailablePNL(market, bank) {
+    return (0, bankBalance_1.getTokenAmount)(market.pnlPool.balance, bank, types_1.BankBalanceType.DEPOSIT);
+}
+exports.calculateMarketAvailablePNL = calculateMarketAvailablePNL;