@drift-labs/sdk 0.2.0-master.4 → 0.2.0-master.40

package/src/math/bankBalance.ts

@@ -1,112 +0,0 @@
-import { BankAccount, BankBalanceType, isVariant } from '../types';
-import { BN } from '@project-serum/anchor';
-import {
-	BANK_UTILIZATION_PRECISION,
-	ONE,
-	TEN,
-	ZERO,
-	BANK_INTEREST_PRECISION,
-	ONE_YEAR,
-} from '../constants/numericConstants';
-
-export function getBalance(
-	tokenAmount: BN,
-	bank: BankAccount,
-	balanceType: BankBalanceType
-): BN {
-	const precisionIncrease = TEN.pow(new BN(16 - bank.decimals));
-
-	const cumulativeInterest = isVariant(balanceType, 'deposit')
-		? bank.cumulativeDepositInterest
-		: bank.cumulativeBorrowInterest;
-
-	let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
-
-	if (!balance.eq(ZERO) && isVariant(balanceType, 'borrow')) {
-		balance = balance.add(ONE);
-	}
-
-	return balance;
-}
-
-export function getTokenAmount(
-	balanceAmount: BN,
-	bank: BankAccount,
-	balanceType: BankBalanceType
-): BN {
-	const precisionDecrease = TEN.pow(new BN(16 - bank.decimals));
-
-	const cumulativeInterest = isVariant(balanceType, 'deposit')
-		? bank.cumulativeDepositInterest
-		: bank.cumulativeBorrowInterest;
-
-	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
-}
-
-export function calculateInterestAccumulated(
-	bank: BankAccount,
-	now: BN
-): { borrowInterest: BN; depositInterest: BN } {
-	const token_deposit_amount = getTokenAmount(
-		bank.depositBalance,
-		bank,
-		BankBalanceType.DEPOSIT
-	);
-	const token_borrow_amount = getTokenAmount(
-		bank.borrowBalance,
-		bank,
-		BankBalanceType.BORROW
-	);
-
-	let utilization: BN;
-	if (token_borrow_amount.eq(ZERO) && token_deposit_amount.eq(ZERO)) {
-		utilization = ZERO;
-	} else if (token_deposit_amount.eq(ZERO)) {
-		utilization = BANK_UTILIZATION_PRECISION;
-	} else {
-		utilization = token_borrow_amount
-			.mul(BANK_UTILIZATION_PRECISION)
-			.div(token_deposit_amount);
-	}
-
-	let interest_rate: BN;
-	if (utilization.gt(bank.optimalUtilization)) {
-		const surplusUtilization = utilization.sub(bank.optimalUtilization);
-		const borrowRateSlope = bank.maxBorrowRate
-			.sub(bank.optimalBorrowRate)
-			.mul(BANK_UTILIZATION_PRECISION)
-			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-
-		interest_rate = bank.optimalBorrowRate.add(
-			surplusUtilization.mul(borrowRateSlope).div(BANK_UTILIZATION_PRECISION)
-		);
-	} else {
-		const borrowRateSlope = bank.optimalBorrowRate
-			.mul(BANK_UTILIZATION_PRECISION)
-			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
-
-		interest_rate = utilization
-			.mul(borrowRateSlope)
-			.div(BANK_UTILIZATION_PRECISION);
-	}
-
-	const timeSinceLastUpdate = now.sub(bank.lastUpdated);
-
-	const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
-
-	const modifiedDepositRate = modifiedBorrowRate
-		.mul(utilization)
-		.div(BANK_UTILIZATION_PRECISION);
-
-	const borrowInterest = bank.cumulativeBorrowInterest
-		.mul(modifiedBorrowRate)
-		.div(ONE_YEAR)
-		.div(BANK_INTEREST_PRECISION)
-		.add(ONE);
-	const depositInterest = bank.cumulativeDepositInterest
-		.mul(modifiedDepositRate)
-		.div(ONE_YEAR)
-		.div(BANK_INTEREST_PRECISION);
-
-	return { borrowInterest, depositInterest };
-}

package/src/math/state.ts

@@ -1,14 +0,0 @@
-import { StateAccount } from '../types';
-
-/**
- * Get the clearing house percent fee charged on notional of taking trades
- *
- * @param state
- * @returns Precision : basis points (bps)
- */
-export function getExchangeFee(state: StateAccount): number {
-	const exchangeFee =
-		state.feeStructure.feeNumerator.toNumber() /
-		state.feeStructure.feeDenominator.toNumber();
-	return exchangeFee;
-}

package/src/math/utils.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.squareRootBN = void 0;
-const __1 = require("../");
-const squareRootBN = (n, closeness = new __1.BN(1)) => {
-    // Assuming the sqrt of n as n only
-    let x = n;
-    // The closed guess will be stored in the root
-    let root;
-    // To count the number of iterations
-    let count = 0;
-    const TWO = new __1.BN(2);
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    while (count < Number.MAX_SAFE_INTEGER) {
-        count++;
-        // Calculate more closed x
-        root = x.add(n.div(x)).div(TWO);
-        // Check for closeness
-        if (x.sub(root).abs().lte(closeness))
-            break;
-        // Update root
-        x = root;
-    }
-    return root;
-};
-exports.squareRootBN = squareRootBN;
-//# sourceMappingURL=utils.js.map

package/src/math/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/orders.ts

@@ -1,244 +0,0 @@
-import {
-	isVariant,
-	MarketAccount,
-	Order,
-	PositionDirection,
-	UserAccount,
-	UserPosition,
-} from './types';
-import { BN, standardizeBaseAssetAmount } from '.';
-import { calculateNewMarketAfterTrade } from './math/market';
-import {
-	AMM_TO_QUOTE_PRECISION_RATIO,
-	PEG_PRECISION,
-	ZERO,
-} from './constants/numericConstants';
-import { calculateMaxBaseAssetAmountToTrade } from './math/amm';
-import {
-	findDirectionToClose,
-	positionCurrentDirection,
-} from './math/position';
-import { OraclePriceData } from '.';
-
-export function calculateNewStateAfterOrder(
-	userAccount: UserAccount,
-	userPosition: UserPosition,
-	market: MarketAccount,
-	order: Order
-): [UserAccount, UserPosition, MarketAccount] | null {
-	if (isVariant(order.status, 'init')) {
-		return null;
-	}
-
-	const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(
-		market,
-		order
-	);
-	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
-		return null;
-	}
-
-	const userAccountAfter = Object.assign({}, userAccount);
-	const userPositionAfter = Object.assign({}, userPosition);
-
-	const currentPositionDirection = positionCurrentDirection(userPosition);
-	const increasePosition =
-		userPosition.baseAssetAmount.eq(ZERO) ||
-		isSameDirection(order.direction, currentPositionDirection);
-
-	if (increasePosition) {
-		const marketAfter = calculateNewMarketAfterTrade(
-			baseAssetAmountToTrade,
-			order.direction,
-			market
-		);
-
-		const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-			calculateAmountSwapped(market, marketAfter);
-
-		userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-			baseAssetAmountSwapped
-		);
-		userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(
-			quoteAssetAmountSwapped
-		);
-
-		return [userAccountAfter, userPositionAfter, marketAfter];
-	} else {
-		const reversePosition = baseAssetAmountToTrade.gt(
-			userPosition.baseAssetAmount.abs()
-		);
-
-		if (reversePosition) {
-			const intermediateMarket = calculateNewMarketAfterTrade(
-				userPosition.baseAssetAmount,
-				findDirectionToClose(userPosition),
-				market
-			);
-
-			const { quoteAssetAmountSwapped: baseAssetValue } =
-				calculateAmountSwapped(market, intermediateMarket);
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
-			} else {
-				pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			const baseAssetAmountLeft = baseAssetAmountToTrade.sub(
-				userPosition.baseAssetAmount.abs()
-			);
-
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountLeft,
-				order.direction,
-				intermediateMarket
-			);
-
-			const { quoteAssetAmountSwapped, baseAssetAmountSwapped } =
-				calculateAmountSwapped(intermediateMarket, marketAfter);
-
-			userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
-			userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		} else {
-			const marketAfter = calculateNewMarketAfterTrade(
-				baseAssetAmountToTrade,
-				order.direction,
-				market
-			);
-
-			const {
-				quoteAssetAmountSwapped: baseAssetValue,
-				baseAssetAmountSwapped,
-			} = calculateAmountSwapped(market, marketAfter);
-
-			const costBasisRealized = userPosition.quoteAssetAmount
-				.mul(baseAssetAmountSwapped.abs())
-				.div(userPosition.baseAssetAmount.abs());
-
-			let pnl;
-			if (isVariant(currentPositionDirection, 'long')) {
-				pnl = baseAssetValue.sub(costBasisRealized);
-			} else {
-				pnl = costBasisRealized.sub(baseAssetValue);
-			}
-
-			userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
-
-			userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(
-				baseAssetAmountSwapped
-			);
-			userPositionAfter.quoteAssetAmount =
-				userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
-
-			return [userAccountAfter, userPositionAfter, marketAfter];
-		}
-	}
-}
-
-function calculateAmountSwapped(
-	marketBefore: MarketAccount,
-	marketAfter: MarketAccount
-): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
-	return {
-		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
-			.sub(marketAfter.amm.quoteAssetReserve)
-			.abs()
-			.mul(marketBefore.amm.pegMultiplier)
-			.div(PEG_PRECISION)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO),
-		baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(
-			marketAfter.amm.baseAssetReserve
-		),
-	};
-}
-
-export function calculateBaseAssetAmountMarketCanExecute(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	if (isVariant(order.orderType, 'limit')) {
-		return calculateAmountToTradeForLimit(market, order, oraclePriceData);
-	} else if (isVariant(order.orderType, 'triggerLimit')) {
-		return calculateAmountToTradeForTriggerLimit(market, order);
-	} else if (isVariant(order.orderType, 'market')) {
-		return ZERO;
-	} else {
-		return calculateAmountToTradeForTriggerMarket(market, order);
-	}
-}
-
-export function calculateAmountToTradeForLimit(
-	market: MarketAccount,
-	order: Order,
-	oraclePriceData?: OraclePriceData
-): BN {
-	let limitPrice = order.price;
-	if (!order.oraclePriceOffset.eq(ZERO)) {
-		if (!oraclePriceData) {
-			throw Error(
-				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
-			);
-		}
-		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-	}
-
-	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
-		market.amm,
-		limitPrice,
-		order.direction
-	);
-
-	const baseAssetAmount = standardizeBaseAssetAmount(
-		maxAmountToTrade,
-		market.amm.baseAssetAmountStepSize
-	);
-
-	// Check that directions are the same
-	const sameDirection = isSameDirection(direction, order.direction);
-	if (!sameDirection) {
-		return ZERO;
-	}
-
-	return baseAssetAmount.gt(order.baseAssetAmount)
-		? order.baseAssetAmount
-		: baseAssetAmount;
-}
-
-export function calculateAmountToTradeForTriggerLimit(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return calculateAmountToTradeForLimit(market, order);
-}
-
-function isSameDirection(
-	firstDirection: PositionDirection,
-	secondDirection: PositionDirection
-): boolean {
-	return (
-		(isVariant(firstDirection, 'long') && isVariant(secondDirection, 'long')) ||
-		(isVariant(firstDirection, 'short') && isVariant(secondDirection, 'short'))
-	);
-}
-
-function calculateAmountToTradeForTriggerMarket(
-	market: MarketAccount,
-	order: Order
-): BN {
-	if (!order.triggered) {
-		return ZERO;
-	}
-
-	return order.baseAssetAmount;
-}

package/src/util/computeUnits.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findComputeUnitConsumption = void 0;
-async function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
-    const tx = await connection.getTransaction(txSignature, { commitment });
-    const computeUnits = [];
-    const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of 200000 compute units`);
-    tx.meta.logMessages.forEach((logMessage) => {
-        const match = logMessage.match(regex);
-        if (match && match[1]) {
-            computeUnits.push(match[1]);
-        }
-    });
-    return computeUnits;
-}
-exports.findComputeUnitConsumption = findComputeUnitConsumption;
-//# sourceMappingURL=computeUnits.js.map

package/src/util/computeUnits.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeUnits.js","sourceRoot":"","sources":["computeUnits.ts"],"names":[],"mappings":";;;AAEO,KAAK,UAAU,0BAA0B,CAC/C,SAAoB,EACpB,UAAsB,EACtB,WAAmB,EACnB,aAAuB,WAAW;IAElC,MAAM,EAAE,GAAG,MAAM,UAAU,CAAC,cAAc,CAAC,WAAW,EAAE,EAAE,UAAU,EAAE,CAAC,CAAC;IACxE,MAAM,YAAY,GAAG,EAAE,CAAC;IACxB,MAAM,KAAK,GAAG,IAAI,MAAM,CACvB,WAAW,SAAS,CAAC,QAAQ,EAAE,gDAAgD,CAC/E,CAAC;IACF,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,UAAU,EAAE,EAAE;QAC1C,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE;YACtB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SAC5B;IACF,CAAC,CAAC,CAAC;IACH,OAAO,YAAY,CAAC;AACrB,CAAC;AAlBD,gEAkBC"}