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

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

@@ -187,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);
 
@@ -207,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/oracles.ts

@@ -1,6 +1,11 @@
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
-import { ONE, ZERO } from '../constants/numericConstants';
+import {
+	BID_ASK_SPREAD_PRECISION,
+	MARK_PRICE_PRECISION,
+	ONE,
+	ZERO,
+} from '../constants/numericConstants';
 import { BN } from '../index';
 
 export function isOracleValid(
@@ -9,7 +14,7 @@ export function isOracleValid(
 	oracleGuardRails: OracleGuardRails,
 	slot: number
 ): boolean {
-	const isOraclePriceNonPositive = oraclePriceData.price.lt(ZERO);
+	const isOraclePriceNonPositive = oraclePriceData.price.lte(ZERO);
 	const isOraclePriceTooVolatile =
 		oraclePriceData.price
 			.div(BN.max(ONE, amm.lastOraclePriceTwap))
@@ -18,9 +23,11 @@ export function isOracleValid(
 			.div(BN.max(ONE, oraclePriceData.price))
 			.gt(oracleGuardRails.validity.tooVolatileRatio);
 
-	const isConfidenceTooLarge = oraclePriceData.price
-		.div(BN.max(ONE, oraclePriceData.confidence))
-		.lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+	const isConfidenceTooLarge = new BN(amm.baseSpread)
+		.add(BN.max(ONE, oraclePriceData.confidence))
+		.mul(BID_ASK_SPREAD_PRECISION)
+		.div(oraclePriceData.price)
+		.gt(new BN(amm.maxSpread));
 
 	const oracleIsStale = oraclePriceData.slot
 		.sub(new BN(slot))
@@ -34,3 +41,33 @@ export function isOracleValid(
 		isConfidenceTooLarge
 	);
 }
+
+export function isOracleTooDivergent(
+	amm: AMM,
+	oraclePriceData: OraclePriceData,
+	oracleGuardRails: OracleGuardRails,
+	now: BN
+): boolean {
+	const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+	const sinceStart = BN.max(ZERO, new BN(60 * 5).sub(sinceLastUpdate));
+	const oracleTwap5min = amm.lastOraclePriceTwap5min
+		.mul(sinceStart)
+		.add(oraclePriceData.price)
+		.mul(sinceLastUpdate)
+		.div(sinceStart.add(sinceLastUpdate));
+
+	const oracleSpread = oracleTwap5min.sub(oraclePriceData.price);
+	const oracleSpreadPct = oracleSpread
+		.mul(MARK_PRICE_PRECISION)
+		.div(oracleTwap5min);
+
+	const tooDivergent = oracleSpreadPct
+		.abs()
+		.gte(
+			BID_ASK_SPREAD_PRECISION.mul(
+				oracleGuardRails.priceDivergence.markOracleDivergenceNumerator
+			).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator)
+		);
+
+	return tooDivergent;
+}

package/src/math/position.ts

@@ -189,7 +189,8 @@ export function positionIsAvailable(position: UserPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders.eq(ZERO) &&
-		position.quoteAssetAmount.eq(ZERO)
+		position.quoteAssetAmount.eq(ZERO) &&
+		position.lpShares.eq(ZERO)
 	);
 }
 

package/src/math/trade.ts

@@ -177,13 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	const acquiredQuoteAssetamount = calculateQuoteAssetAmountSwapped(
+	const acquiredQuoteAssetAmount = calculateQuoteAssetAmountSwapped(
 		acquiredQuote.abs(),
 		amm.pegMultiplier,
 		swapDirection
 	);
 
-	return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 
 /**

package/src/types.ts

@@ -177,6 +177,8 @@ export type LiquidationRecord = {
 	liquidateBorrow: LiquidateBorrowRecord;
 	liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
 	liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
+	perpBankruptcy: PerpBankruptcyRecord;
+	borrowBankruptcy: BorrowBankruptcyRecord;
 };
 
 export class LiquidationType {
@@ -188,6 +190,12 @@ export class LiquidationType {
 	static readonly LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
 		liquidatePerpPnlForDeposit: {},
 	};
+	static readonly PERP_BANKRUPTCY = {
+		perpBankruptcy: {},
+	};
+	static readonly BORROW_BANKRUPTCY = {
+		borrowBankruptcy: {},
+	};
 }
 
 export type LiquidatePerpRecord = {
@@ -231,14 +239,27 @@ export type LiquidatePerpPnlForDepositRecord = {
 	assetTransfer: BN;
 };
 
+export type PerpBankruptcyRecord = {
+	marketIndex: BN;
+	pnl: BN;
+	cumulativeFundingRateDelta: BN;
+};
+
+export type BorrowBankruptcyRecord = {
+	bankIndex: BN;
+	borrowAmount: BN;
+	cumulativeDepositInterestDelta: BN;
+};
+
 export type SettlePnlRecord = {
 	ts: BN;
+	user: PublicKey;
 	marketIndex: BN;
 	pnl: BN;
 	baseAssetAmount: BN;
 	quoteAssetAmountAfter: BN;
 	quoteEntryamount: BN;
-	oraclePrice: BN;
+	settlePrice: BN;
 };
 
 export type OrderRecord = {
@@ -329,7 +350,8 @@ export type BankAccount = {
 	cumulativeBorrowInterest: BN;
 	depositBalance: BN;
 	borrowBalance: BN;
-	lastUpdated: BN;
+	lastInterestTs: BN;
+	lastTwapTs: BN;
 	oracle: PublicKey;
 	initialAssetWeight: BN;
 	maintenanceAssetWeight: BN;
@@ -337,6 +359,11 @@ export type BankAccount = {
 	maintenanceLiabilityWeight: BN;
 	liquidationFee: BN;
 	imfFactor: BN;
+
+	withdrawGuardThreshold: BN;
+	depositTokenTwap: BN;
+	borrowTokenTwap: BN;
+	utilizationTwap: BN;
 };
 
 export type PoolBalance = {
@@ -350,8 +377,10 @@ export type AMM = {
 	lastFundingRate: BN;
 	lastFundingRateTs: BN;
 	lastMarkPriceTwap: BN;
+	lastMarkPriceTwap5min: BN;
 	lastMarkPriceTwapTs: BN;
 	lastOraclePriceTwap: BN;
+	lastOraclePriceTwap5min: BN;
 	lastOraclePriceTwapTs: BN;
 	lastOracleMarkSpreadPct: BN;
 	lastOracleConfPct: BN;
@@ -362,11 +391,16 @@ export type AMM = {
 	pegMultiplier: BN;
 	cumulativeFundingRateLong: BN;
 	cumulativeFundingRateShort: BN;
+	cumulativeFundingRateLp: BN;
 	cumulativeRepegRebateLong: BN;
 	cumulativeRepegRebateShort: BN;
 	totalFeeMinusDistributions: BN;
 	totalFeeWithdrawn: BN;
 	totalFee: BN;
+	cumulativeFundingPaymentPerLp: BN;
+	cumulativeFeePerLp: BN;
+	cumulativeNetBaseAssetAmountPerLp: BN;
+	userLpShares: BN;
 	minimumQuoteAssetTradeSize: BN;
 	baseAssetAmountStepSize: BN;
 	maxBaseAssetAmountRatio: number;
@@ -388,6 +422,8 @@ export type AMM = {
 	longSpread: BN;
 	shortSpread: BN;
 	maxSpread: number;
+	marketPosition: UserPosition;
+	marketPositionPerLp: UserPosition;
 };
 
 // # User Account Types
@@ -400,15 +436,21 @@ export type UserPosition = {
 	openOrders: BN;
 	openBids: BN;
 	openAsks: BN;
+	realizedPnl: BN;
+	lpShares: BN;
+	lastFeePerLp: BN;
+	lastNetBaseAssetAmountPerLp: BN;
+	lastNetQuoteAssetAmountPerLp: BN;
 };
 
-export type UserAccount = {
-	authority: PublicKey;
-	name: number[];
-	userId: number;
-	bankBalances: UserBankBalance[];
-	collateral: BN;
-	cumulativeDeposits: BN;
+export type UserStatsAccount = {
+	numberOfUsers: number;
+	makerVolume30D: BN;
+	takerVolume30D: BN;
+	fillerVolume30D: BN;
+	lastMakerVolume30DTs: BN;
+	lastTakerVolume30DTs: BN;
+	lastFillerVolume30DTs: BN;
 	fees: {
 		totalFeePaid: BN;
 		totalFeeRebate: BN;
@@ -416,9 +458,17 @@ export type UserAccount = {
 		totalReferralReward: BN;
 		totalRefereeDiscount: BN;
 	};
+};
+
+export type UserAccount = {
+	authority: PublicKey;
+	name: number[];
+	userId: number;
+	bankBalances: UserBankBalance[];
 	positions: UserPosition[];
 	orders: Order[];
 	beingLiquidated: boolean;
+	bankrupt: boolean;
 	nextLiquidationId: number;
 };
 
@@ -515,11 +565,13 @@ export const DefaultOrderParams = {
 
 export type MakerInfo = {
 	maker: PublicKey;
+	makerStats: PublicKey;
 	order: Order;
 };
 
 export type TakerInfo = {
 	taker: PublicKey;
+	takerStats: PublicKey;
 	order: Order;
 };
 

package/tests/bn/test.ts

@@ -127,6 +127,14 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('123456789').toMillified(5)).to.equal('123.45M');
 
 		expect(BigNum.from(-95, 2).print()).to.equal('-0.95');
+
+		// Case 6 strange numbers
+		expect(BigNum.from('-100', 2).print()).to.equal('-1.00');
+		expect(BigNum.from('-8402189', 13).print()).to.equal('-0.0000008402189');
+		expect(BigNum.from('-10000000000000', 13).print()).to.equal(
+			'-1.0000000000000'
+		);
+		expect(BigNum.from('-100', 6).print()).to.equal('-0.000100');
 	});
 
 	it('can initialise from string values correctly', () => {

package/src/accounts/bulkAccountLoader.js

@@ -1,197 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BulkAccountLoader = void 0;
-const uuid_1 = require("uuid");
-const promiseTimeout_1 = require("../util/promiseTimeout");
-const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
-const oneMinute = 60 * 1000;
-class BulkAccountLoader {
-    constructor(connection, commitment, pollingFrequency) {
-        this.accountsToLoad = new Map();
-        this.bufferAndSlotMap = new Map();
-        this.errorCallbacks = new Map();
-        this.lastTimeLoadingPromiseCleared = Date.now();
-        this.mostRecentSlot = 0;
-        this.connection = connection;
-        this.commitment = commitment;
-        this.pollingFrequency = pollingFrequency;
-    }
-    addAccount(publicKey, callback) {
-        const existingSize = this.accountsToLoad.size;
-        const callbackId = uuid_1.v4();
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.set(callbackId, callback);
-        }
-        else {
-            const callbacks = new Map();
-            callbacks.set(callbackId, callback);
-            const newAccountToLoad = {
-                publicKey,
-                callbacks,
-            };
-            this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
-        }
-        if (existingSize === 0) {
-            this.startPolling();
-        }
-        // if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
-        this.loadPromise = undefined;
-        return callbackId;
-    }
-    removeAccount(publicKey, callbackId) {
-        const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
-        if (existingAccountToLoad) {
-            existingAccountToLoad.callbacks.delete(callbackId);
-            if (existingAccountToLoad.callbacks.size === 0) {
-                this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
-            }
-        }
-        if (this.accountsToLoad.size === 0) {
-            this.stopPolling();
-        }
-    }
-    addErrorCallbacks(callback) {
-        const callbackId = uuid_1.v4();
-        this.errorCallbacks.set(callbackId, callback);
-        return callbackId;
-    }
-    removeErrorCallbacks(callbackId) {
-        this.errorCallbacks.delete(callbackId);
-    }
-    chunks(array, size) {
-        return new Array(Math.ceil(array.length / size))
-            .fill(null)
-            .map((_, index) => index * size)
-            .map((begin) => array.slice(begin, begin + size));
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.loadPromise) {
-                const now = Date.now();
-                if (now - this.lastTimeLoadingPromiseCleared > oneMinute) {
-                    this.loadPromise = undefined;
-                }
-                else {
-                    return this.loadPromise;
-                }
-            }
-            this.loadPromise = new Promise((resolver) => {
-                this.loadPromiseResolver = resolver;
-            });
-            this.lastTimeLoadingPromiseCleared = Date.now();
-            try {
-                const chunks = this.chunks(Array.from(this.accountsToLoad.values()), GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE);
-                yield Promise.all(chunks.map((chunk) => {
-                    return this.loadChunk(chunk);
-                }));
-            }
-            catch (e) {
-                console.error(`Error in bulkAccountLoader.load()`);
-                console.error(e);
-                for (const [_, callback] of this.errorCallbacks) {
-                    callback(e);
-                }
-            }
-            finally {
-                this.loadPromiseResolver();
-                this.loadPromise = undefined;
-            }
-        });
-    }
-    loadChunk(accountsToLoad) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (accountsToLoad.length === 0) {
-                return;
-            }
-            const args = [
-                accountsToLoad.map((accountToLoad) => {
-                    return accountToLoad.publicKey.toBase58();
-                }),
-                { commitment: this.commitment },
-            ];
-            const rpcResponse = yield promiseTimeout_1.promiseTimeout(
-            // @ts-ignore
-            this.connection._rpcRequest('getMultipleAccounts', args), 10 * 1000 // 30 second timeout
-            );
-            if (rpcResponse === null) {
-                this.log('request to rpc timed out');
-                return;
-            }
-            const newSlot = rpcResponse.result.context.slot;
-            if (newSlot > this.mostRecentSlot) {
-                this.mostRecentSlot = newSlot;
-            }
-            for (const i in accountsToLoad) {
-                const accountToLoad = accountsToLoad[i];
-                const key = accountToLoad.publicKey.toString();
-                const oldRPCResponse = this.bufferAndSlotMap.get(key);
-                let newBuffer = undefined;
-                if (rpcResponse.result.value[i]) {
-                    const raw = rpcResponse.result.value[i].data[0];
-                    const dataType = rpcResponse.result.value[i].data[1];
-                    newBuffer = Buffer.from(raw, dataType);
-                }
-                if (!oldRPCResponse) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                    continue;
-                }
-                if (newSlot <= oldRPCResponse.slot) {
-                    continue;
-                }
-                const oldBuffer = oldRPCResponse.buffer;
-                if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-                    this.bufferAndSlotMap.set(key, {
-                        slot: newSlot,
-                        buffer: newBuffer,
-                    });
-                    this.handleAccountCallbacks(accountToLoad, newBuffer, newSlot);
-                }
-            }
-        });
-    }
-    handleAccountCallbacks(accountToLoad, buffer, slot) {
-        for (const [_, callback] of accountToLoad.callbacks) {
-            callback(buffer, slot);
-        }
-    }
-    getBufferAndSlot(publicKey) {
-        return this.bufferAndSlotMap.get(publicKey.toString());
-    }
-    startPolling() {
-        if (this.intervalId) {
-            return;
-        }
-        this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
-    }
-    stopPolling() {
-        if (this.intervalId) {
-            clearInterval(this.intervalId);
-            this.intervalId = undefined;
-        }
-    }
-    log(msg) {
-        console.log(msg);
-    }
-    updatePollingFrequency(pollingFrequency) {
-        this.stopPolling();
-        this.pollingFrequency = pollingFrequency;
-        if (this.accountsToLoad.size > 0) {
-            this.startPolling();
-        }
-    }
-}
-exports.BulkAccountLoader = BulkAccountLoader;

package/src/accounts/bulkUserSubscription.js

@@ -1,33 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bulkPollingUserSubscribe = void 0;
-/**
- * @param users
- * @param accountLoader
- */
-function bulkPollingUserSubscribe(users, accountLoader) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (users.length === 0) {
-            yield accountLoader.load();
-            return;
-        }
-        yield Promise.all(users.map((user) => {
-            // Pull the keys from the authority map so we can skip fetching them in addToAccountLoader
-            return user.accountSubscriber.addToAccountLoader();
-        }));
-        yield accountLoader.load();
-        yield Promise.all(users.map((user) => __awaiter(this, void 0, void 0, function* () {
-            return user.subscribe();
-        })));
-    });
-}
-exports.bulkPollingUserSubscribe = bulkPollingUserSubscribe;