@drift-labs/sdk 0.2.0-master.2 → 0.2.0-master.22

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.ts

@@ -1,7 +1,8 @@
 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';
@@ -11,14 +12,19 @@ export * from './accounts/fetch';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
+export * from './accounts/bulkUserStatsSubscription';
 export * from './accounts/pollingClearingHouseAccountSubscriber';
 export * from './accounts/pollingOracleSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
+export * from './accounts/pollingUserAccountSubscriber';
+export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './admin';
 export * from './clearingHouseUser';
 export * from './clearingHouseUserConfig';
+export * from './clearingHouseUserStats';
+export * from './clearingHouseUserStatsConfig';
 export * from './clearingHouse';
 export * from './factory/oracleClient';
 export * from './factory/bigNum';
@@ -34,7 +40,7 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
-export * from './orders';
+export * from './math/margin';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';
@@ -49,4 +55,4 @@ export * from './math/bankBalance';
 export * from './constants/banks';
 export * from './clearingHouseConfig';
 
-export { BN, PublicKey };
+export { BN, PublicKey, pyth };

package/src/math/amm.ts

@@ -19,7 +19,7 @@ import {
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import { squareRootBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -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(
@@ -68,6 +71,7 @@ export function calculateOptimalPegAndBudget(
 		let newOptimalPeg: BN;
 		let newBudget: BN;
 		const targetPriceGap = markPriceBefore.sub(targetPrice);
+
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
@@ -411,10 +415,8 @@ export function calculateSpread(
 	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
 ): number {
-	let spread = amm.baseSpread / 2;
-
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return spread;
+		return amm.baseSpread / 2;
 	}
 
 	const markPrice = calculatePrice(
@@ -435,54 +437,25 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(markPrice);
 
-	// oracle retreat
-	if (
-		(isVariant(direction, 'long') && targetMarkSpreadPct.lt(ZERO)) ||
-		(isVariant(direction, 'short') && targetMarkSpreadPct.gt(ZERO))
-	) {
-		spread = Math.max(
-			spread,
-			targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber()
-		);
-	}
-
-	// inventory skew
-	const MAX_INVENTORY_SKEW = 5;
-	if (
-		(amm.netBaseAssetAmount.gt(ZERO) && isVariant(direction, 'long')) ||
-		(amm.netBaseAssetAmount.lt(ZERO) && isVariant(direction, 'short')) ||
-		amm.totalFeeMinusDistributions.eq(ZERO)
-	) {
-		const netCostBasis = amm.quoteAssetAmountLong.sub(
-			amm.quoteAssetAmountShort
-		);
-		const netBaseAssetValue = amm.quoteAssetReserve
-			.sub(amm.terminalQuoteAssetReserve)
-			.mul(amm.pegMultiplier)
-			.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-
-		const localBaseAssetValue = amm.netBaseAssetAmount
-			.mul(markPrice)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
-		const netPnl = netBaseAssetValue.sub(netCostBasis);
-		const localPnl = localBaseAssetValue.sub(netCostBasis);
-
-		let effectiveLeverage = MAX_INVENTORY_SKEW;
-		if (amm.totalFeeMinusDistributions.gt(ZERO)) {
-			effectiveLeverage =
-				localPnl.sub(netPnl).toNumber() /
-				(amm.totalFeeMinusDistributions.toNumber() + 1);
-		}
+	const [longSpread, shortSpread] = calculateSpreadBN(
+		amm.baseSpread,
+		targetMarkSpreadPct,
+		confIntervalPct,
+		amm.maxSpread,
+		amm.quoteAssetReserve,
+		amm.terminalQuoteAssetReserve,
+		amm.pegMultiplier,
+		amm.netBaseAssetAmount,
+		markPrice,
+		amm.totalFeeMinusDistributions
+	);
 
-		let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
-		const maxTargetSpread = BID_ASK_SPREAD_PRECISION.toNumber() / 50; // 2%
-		// cap the scale to attempt to only scale up to maxTargetSpread
-		// always let the oracle retreat methods go through 100%
-		if (spreadScale * spread > maxTargetSpread) {
-			spreadScale = Math.max(1.05, maxTargetSpread / spread);
-		}
+	let spread: number;
 
-		spread *= spreadScale;
+	if (isVariant(direction, 'long')) {
+		spread = longSpread;
+	} else {
+		spread = shortSpread;
 	}
 
 	return spread;
@@ -650,3 +623,29 @@ export function calculateQuoteAssetAmountSwapped(
 
 	return quoteAssetAmount;
 }
+
+export function calculateMaxBaseAssetAmountFillable(
+	amm: AMM,
+	orderDirection: PositionDirection
+): BN {
+	const maxFillSize = amm.baseAssetReserve.div(
+		new BN(amm.maxBaseAssetAmountRatio)
+	);
+	let maxBaseAssetAmountOnSide: BN;
+	if (isVariant(orderDirection, 'long')) {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+		);
+	} else {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+		);
+	}
+
+	return standardizeBaseAssetAmount(
+		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
+		amm.baseAssetAmountStepSize
+	);
+}

package/src/math/auction.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuctionPrice = exports.isAuctionComplete = void 0;
+const types_1 = require("../types");
+const _1 = require("../.");
+function isAuctionComplete(order, slot) {
+    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) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return order.auctionEndPrice;
+    }
+    let priceDelta;
+    if (types_1.isVariant(order.direction, 'long')) {
+        priceDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let price;
+    if (types_1.isVariant(order.direction, 'long')) {
+        price = order.auctionStartPrice.add(priceDelta);
+    }
+    else {
+        price = order.auctionStartPrice.sub(priceDelta);
+    }
+    return price;
+}
+exports.getAuctionPrice = getAuctionPrice;

package/src/math/auction.ts

@@ -2,7 +2,11 @@ import { isVariant, Order } from '../types';
 import { BN, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
-	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
 }
 
 export function getAuctionPrice(order: Order, slot: number): BN {

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
@@ -90,7 +187,7 @@ export function calculateInterestAccumulated(
 			.div(BANK_UTILIZATION_PRECISION);
 	}
 
-	const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+	const timeSinceLastUpdate = now.sub(bank.lastInterestTs);
 
 	const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
 
@@ -110,3 +207,52 @@ export function calculateInterestAccumulated(
 
 	return { borrowInterest, depositInterest };
 }
+
+export function calculateWithdrawLimit(
+	bank: BankAccount,
+	now: BN
+): { borrowLimit: BN; withdrawLimit: BN } {
+	const bankDepositTokenAmount = getTokenAmount(
+		bank.depositBalance,
+		bank,
+		BankBalanceType.DEPOSIT
+	);
+	const bankBorrowTokenAmount = getTokenAmount(
+		bank.borrowBalance,
+		bank,
+		BankBalanceType.BORROW
+	);
+
+	const twentyFourHours = new BN(60 * 60 * 24);
+	const sinceLast = now.sub(bank.lastTwapTs);
+	const sinceStart = BN.max(ZERO, twentyFourHours.sub(sinceLast));
+	const borrowTokenTwapLive = bank.borrowTokenTwap
+		.mul(sinceStart)
+		.add(bankBorrowTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const depositTokenTwapLive = bank.depositTokenTwap
+		.mul(sinceStart)
+		.add(bankDepositTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceLast));
+
+	const maxBorrowTokens = BN.min(
+		BN.max(
+			bankDepositTokenAmount.div(new BN(6)),
+			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
+		),
+		bankDepositTokenAmount.sub(bankDepositTokenAmount.div(new BN(10)))
+	); // between ~15-90% utilization with friction on twap
+
+	const minDepositTokens = depositTokenTwapLive.sub(
+		BN.min(
+			BN.max(depositTokenTwapLive.div(new BN(5)), bank.withdrawGuardThreshold),
+			depositTokenTwapLive
+		)
+	);
+
+	return {
+		borrowLimit: maxBorrowTokens.sub(bankBorrowTokenAmount),
+		withdrawLimit: bankDepositTokenAmount.sub(minDepositTokens),
+	};
+}

package/src/math/conversion.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNumber = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
+    if (!bigNumber)
+        return 0;
+    return (bigNumber.div(precision).toNumber() +
+        bigNumber.mod(precision).toNumber() / precision.toNumber());
+};
+exports.convertToNumber = convertToNumber;