@drift-labs/sdk 0.2.0-master.10 → 0.2.0-master.13

package/src/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/src/index.js

@@ -20,7 +20,7 @@ const web3_js_1 = require("@solana/web3.js");
 Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return web3_js_1.PublicKey; } });
 const client_1 = __importDefault(require("@pythnetwork/client"));
 exports.pyth = client_1.default;
-__exportStar(require("./mockUSDCFaucet"), exports);
+__exportStar(require("./tokenFaucet"), exports);
 __exportStar(require("./oracles/types"), exports);
 __exportStar(require("./oracles/pythClient"), exports);
 __exportStar(require("./oracles/switchboardClient"), exports);

package/src/index.ts

@@ -2,7 +2,7 @@ import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
 import pyth from '@pythnetwork/client';
 
-export * from './mockUSDCFaucet';
+export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
@@ -35,6 +35,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';

package/src/math/amm.ts

@@ -33,11 +33,14 @@ export function calculatePegFromTargetPrice(
 	baseAssetReserve: BN,
 	quoteAssetReserve: BN
 ): BN {
-	return targetPrice
-		.mul(baseAssetReserve)
-		.div(quoteAssetReserve)
-		.add(PRICE_DIV_PEG.div(new BN(2)))
-		.div(PRICE_DIV_PEG);
+	return BN.max(
+		targetPrice
+			.mul(baseAssetReserve)
+			.div(quoteAssetReserve)
+			.add(PRICE_DIV_PEG.div(new BN(2)))
+			.div(PRICE_DIV_PEG),
+		ONE
+	);
 }
 
 export function calculateOptimalPegAndBudget(

package/src/math/bankBalance.ts

@@ -1,4 +1,9 @@
-import { BankAccount, BankBalanceType, isVariant } from '../types';
+import {
+	BankAccount,
+	BankBalanceType,
+	isVariant,
+	MarginCategory,
+} from '../types';
 import { BN } from '@project-serum/anchor';
 import {
 	BANK_UTILIZATION_PRECISION,
@@ -6,8 +11,14 @@ import {
 	TEN,
 	ZERO,
 	BANK_INTEREST_PRECISION,
+	BANK_WEIGHT_PRECISION,
 	ONE_YEAR,
+	AMM_RESERVE_PRECISION,
 } from '../constants/numericConstants';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 
 export function getBalance(
 	tokenAmount: BN,
@@ -43,6 +54,92 @@ export function getTokenAmount(
 	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 
+export function calculateAssetWeight(
+	balanceAmount: BN,
+	bank: BankAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(bank.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.initialAssetWeight
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.maintenanceAssetWeight
+			);
+			break;
+		default:
+			assetWeight = bank.initialAssetWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateLiabilityWeight(
+	balanceAmount: BN,
+	bank: BankAccount,
+	marginCategory: MarginCategory
+): BN {
+	const sizePrecision = TEN.pow(new BN(bank.decimals));
+	let sizeInAmmReservePrecision;
+	if (sizePrecision.gt(AMM_RESERVE_PRECISION)) {
+		sizeInAmmReservePrecision = balanceAmount.div(
+			sizePrecision.div(AMM_RESERVE_PRECISION)
+		);
+	} else {
+		sizeInAmmReservePrecision = balanceAmount
+			.mul(AMM_RESERVE_PRECISION)
+			.div(sizePrecision);
+	}
+
+	let assetWeight;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.initialLiabilityWeight,
+				BANK_WEIGHT_PRECISION
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				bank.imfFactor,
+				bank.maintenanceLiabilityWeight,
+				BANK_WEIGHT_PRECISION
+			);
+			break;
+		default:
+			assetWeight = bank.initialLiabilityWeight;
+			break;
+	}
+
+	return assetWeight;
+}
+
 export function calculateInterestAccumulated(
 	bank: BankAccount,
 	now: BN

package/src/math/margin.ts

@@ -0,0 +1,124 @@
+import { squareRootBN } from './utils';
+import {
+	BANK_WEIGHT_PRECISION,
+	BANK_IMF_PRECISION,
+	ZERO,
+	BID_ASK_SPREAD_PRECISION,
+	AMM_TO_QUOTE_PRECISION_RATIO,
+	MARK_PRICE_PRECISION,
+} from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { MarketAccount, UserPosition } from '..';
+
+export function calculateSizePremiumLiabilityWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	liabilityWeight: BN,
+	precision: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return liabilityWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const liabilityWeightNumerator = liabilityWeight.sub(
+		liabilityWeight.div(BN.max(new BN(1), BANK_IMF_PRECISION.div(imfFactor)))
+	);
+
+	const sizePremiumLiabilityWeight = liabilityWeightNumerator.add(
+		sizeSqrt // 1e5
+			.mul(imfFactor)
+			.div(new BN(100_000).mul(BANK_IMF_PRECISION).div(precision)) // 1e5
+	);
+
+	const maxLiabilityWeight = BN.max(
+		liabilityWeight,
+		sizePremiumLiabilityWeight
+	);
+	return maxLiabilityWeight;
+}
+
+export function calculateSizeDiscountAssetWeight(
+	size: BN, // AMM_RESERVE_PRECISION
+	imfFactor: BN,
+	assetWeight: BN
+): BN {
+	if (imfFactor.eq(ZERO)) {
+		return assetWeight;
+	}
+
+	const sizeSqrt = squareRootBN(size.div(new BN(1000)).add(new BN(1))); //1e13 -> 1e10 -> 1e5
+	const imfNumerator = BANK_IMF_PRECISION.add(
+		BANK_IMF_PRECISION.div(new BN(10))
+	);
+
+	const sizeDiscountAssetWeight = imfNumerator.mul(BANK_WEIGHT_PRECISION).div(
+		BANK_IMF_PRECISION.add(
+			sizeSqrt // 1e5
+				.mul(imfFactor)
+				.div(new BN(100_000)) // 1e5
+		)
+	);
+
+	const minAssetWeight = BN.min(assetWeight, sizeDiscountAssetWeight);
+
+	return minAssetWeight;
+}
+
+export function calculateOraclePriceForPerpMargin(
+	marketPosition: UserPosition,
+	market: MarketAccount,
+	oraclePriceData: OraclePriceData
+): BN {
+	const oraclePriceOffset = BN.min(
+		new BN(market.amm.maxSpread)
+			.mul(oraclePriceData.price)
+			.div(BID_ASK_SPREAD_PRECISION),
+		oraclePriceData.confidence.add(
+			new BN(market.amm.baseSpread)
+				.mul(oraclePriceData.price)
+				.div(BID_ASK_SPREAD_PRECISION)
+		)
+	);
+
+	let marginPrice: BN;
+	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+		marginPrice = oraclePriceData.price.sub(oraclePriceOffset);
+	} else {
+		marginPrice = oraclePriceData.price.add(oraclePriceOffset);
+	}
+
+	return marginPrice;
+}
+
+export function calculateMarginBaseAssetValue(
+	market: MarketAccount,
+	marketPosition: UserPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const marginPrice = calculateOraclePriceForPerpMargin(
+		marketPosition,
+		market,
+		oraclePriceData
+	);
+	const baseAssetValue = marketPosition.baseAssetAmount
+		.abs()
+		.mul(marginPrice)
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+
+	return baseAssetValue;
+}
+
+export function calculateWorstCaseBaseAssetAmount(
+	marketPosition: UserPosition
+): BN {
+	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;
+	}
+}

package/src/math/market.ts

@@ -1,5 +1,11 @@
 import { BN } from '@project-serum/anchor';
-import { MarketAccount, PositionDirection } from '../types';
+import {
+	MarketAccount,
+	PositionDirection,
+	MarginCategory,
+	BankAccount,
+	BankBalanceType,
+} from '../types';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
@@ -7,7 +13,13 @@ import {
 	getSwapDirection,
 	calculateUpdatedAMM,
 } from './amm';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
 import { OraclePriceData } from '../oracles/types';
+import { MARGIN_PRECISION } from '../constants/numericConstants';
+import { getTokenAmount } from './bankBalance';
 
 /**
  * Calculates market mark price
@@ -103,3 +115,56 @@ export function calculateOracleSpread(
 ): BN {
 	return price.sub(oraclePriceData.price);
 }
+
+export function calculateMarketMarginRatio(
+	market: MarketAccount,
+	size: BN,
+	marginCategory: MarginCategory
+): number {
+	let marginRatio;
+	switch (marginCategory) {
+		case 'Initial':
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				market.imfFactor,
+				new BN(market.marginRatioInitial),
+				MARGIN_PRECISION
+			).toNumber();
+			break;
+		case 'Maintenance':
+			marginRatio = market.marginRatioMaintenance;
+			break;
+	}
+
+	return marginRatio;
+}
+
+export function calculateUnsettledAssetWeight(
+	market: MarketAccount,
+	unsettledPnl: BN,
+	marginCategory: MarginCategory
+): BN {
+	let assetWeight: BN;
+
+	switch (marginCategory) {
+		case 'Initial':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				unsettledPnl,
+				market.unsettledImfFactor,
+				new BN(market.unsettledInitialAssetWeight)
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = new BN(market.unsettledMaintenanceAssetWeight);
+			break;
+	}
+
+	return assetWeight;
+}
+
+export function calculateMarketAvailablePNL(
+	market: MarketAccount,
+	bank: BankAccount
+): BN {
+	return getTokenAmount(market.pnlPool.balance, bank, BankBalanceType.DEPOSIT);
+}

package/src/math/position.ts

@@ -18,6 +18,8 @@ import {
 	getSwapDirection,
 } from './amm';
 
+import { calculateMarginBaseAssetValue } from './margin';
+
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -84,6 +86,7 @@ export function calculateBaseAssetValue(
  * @param market
  * @param marketPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
@@ -93,21 +96,21 @@ export function calculatePositionPNL(
 	oraclePriceData: OraclePriceData
 ): BN {
 	if (marketPosition.baseAssetAmount.eq(ZERO)) {
-		return ZERO;
+		return marketPosition.quoteAssetAmount;
 	}
 
-	const baseAssetValue = calculateBaseAssetValue(
+	const baseAssetValue = calculateMarginBaseAssetValue(
 		market,
 		marketPosition,
 		oraclePriceData
 	);
 
-	let pnl;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
-		pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-	} else {
-		pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
-	}
+	const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+		? new BN(-1)
+		: new BN(1);
+	let pnl = baseAssetValue
+		.mul(baseAssetValueSign)
+		.add(marketPosition.quoteAssetAmount);
 
 	if (withFunding) {
 		const fundingRatePnL = calculatePositionFundingPNL(
@@ -121,6 +124,36 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
+export function calculateUnsettledPnl(
+	market: MarketAccount,
+	marketPosition: UserPosition,
+	oraclePriceData: OraclePriceData
+): BN {
+	const unrealizedPnl = calculatePositionPNL(
+		market,
+		marketPosition,
+		true,
+		oraclePriceData
+	);
+
+	let unsettledPnl = unrealizedPnl;
+	if (unrealizedPnl.gt(ZERO)) {
+		const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(
+			PRICE_TO_QUOTE_PRECISION
+		);
+
+		const maxPositivePnl = BN.max(
+			marketPosition.quoteAssetAmount
+				.add(marketPosition.quoteEntryAmount)
+				.add(fundingPnL),
+			ZERO
+		);
+
+		unsettledPnl = BN.min(maxPositivePnl, unrealizedPnl);
+	}
+	return unsettledPnl;
+}
+
 /**
  *
  * @param market
@@ -156,7 +189,7 @@ export function positionIsAvailable(position: UserPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders.eq(ZERO) &&
-		position.unsettledPnl.eq(ZERO)
+		position.quoteAssetAmount.eq(ZERO)
 	);
 }
 
@@ -170,6 +203,23 @@ export function calculateEntryPrice(userPosition: UserPosition): BN {
 		return ZERO;
 	}
 
+	return userPosition.quoteEntryAmount
+		.mul(MARK_PRICE_PRECISION)
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.div(userPosition.baseAssetAmount)
+		.abs();
+}
+
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+export function calculateCostBasis(userPosition: UserPosition): BN {
+	if (userPosition.baseAssetAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
 	return userPosition.quoteAssetAmount
 		.mul(MARK_PRICE_PRECISION)
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)