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

package/lib/math/bankBalance.d.ts

@@ -9,3 +9,7 @@ export declare function calculateInterestAccumulated(bank: BankAccount, now: BN)
     borrowInterest: BN;
     depositInterest: BN;
 };
+export declare function calculateWithdrawLimit(bank: BankAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+};

package/lib/math/bankBalance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateInterestAccumulated = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenAmount = exports.getBalance = void 0;
+exports.calculateWithdrawLimit = 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");
@@ -126,3 +126,25 @@ function calculateInterestAccumulated(bank, now) {
     return { borrowInterest, depositInterest };
 }
 exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(bank, now) {
+    const bankDepositTokenAmount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
+    const bankBorrowTokenAmount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
+    const twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    const sinceLast = now.sub(bank.lastUpdated);
+    const sinceStart = anchor_1.BN.max(numericConstants_1.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 = anchor_1.BN.min(anchor_1.BN.max(bankDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), bankDepositTokenAmount.sub(bankDepositTokenAmount.div(new anchor_1.BN(10)))); // between ~15-90% utilization with friction on twap
+    const minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), bank.withdrawGuardThreshold), depositTokenTwapLive));
+    return {
+        borrowLimit: maxBorrowTokens.sub(bankBorrowTokenAmount),
+        withdrawLimit: bankDepositTokenAmount.sub(minDepositTokens),
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;

package/lib/math/oracles.d.ts

@@ -1,3 +1,6 @@
+/// <reference types="bn.js" />
 import { AMM, OracleGuardRails } from '../types';
 import { OraclePriceData } from '../oracles/types';
+import { BN } from '../index';
 export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
+export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;

package/lib/math/oracles.js

@@ -1,19 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleValid = void 0;
+exports.isOracleTooDivergent = exports.isOracleValid = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
 function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
-    const isOraclePriceNonPositive = oraclePriceData.price.lt(numericConstants_1.ZERO);
+    const isOraclePriceNonPositive = oraclePriceData.price.lte(numericConstants_1.ZERO);
     const isOraclePriceTooVolatile = oraclePriceData.price
         .div(index_1.BN.max(numericConstants_1.ONE, amm.lastOraclePriceTwap))
         .gt(oracleGuardRails.validity.tooVolatileRatio) ||
         amm.lastOraclePriceTwap
             .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.price))
             .gt(oracleGuardRails.validity.tooVolatileRatio);
-    const isConfidenceTooLarge = oraclePriceData.price
-        .div(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
-        .lt(oracleGuardRails.validity.confidenceIntervalMaxSize);
+    const isConfidenceTooLarge = new index_1.BN(amm.baseSpread)
+        .add(index_1.BN.max(numericConstants_1.ONE, oraclePriceData.confidence))
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(oraclePriceData.price)
+        .gt(new index_1.BN(amm.maxSpread));
     const oracleIsStale = oraclePriceData.slot
         .sub(new index_1.BN(slot))
         .gt(oracleGuardRails.validity.slotsBeforeStale);
@@ -24,3 +26,21 @@ function isOracleValid(amm, oraclePriceData, oracleGuardRails, slot) {
         isConfidenceTooLarge);
 }
 exports.isOracleValid = isOracleValid;
+function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
+    const sinceLastUpdate = now.sub(amm.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, new index_1.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(numericConstants_1.MARK_PRICE_PRECISION)
+        .div(oracleTwap5min);
+    const tooDivergent = oracleSpreadPct
+        .abs()
+        .gte(numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(oracleGuardRails.priceDivergence.markOracleDivergenceNumerator).div(oracleGuardRails.priceDivergence.markOracleDivergenceDenominator));
+    return tooDivergent;
+}
+exports.isOracleTooDivergent = isOracleTooDivergent;

package/lib/math/position.js

@@ -117,7 +117,8 @@ exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
 function positionIsAvailable(position) {
     return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
         position.openOrders.eq(numericConstants_1.ZERO) &&
-        position.quoteAssetAmount.eq(numericConstants_1.ZERO));
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**

package/lib/math/trade.js

@@ -113,8 +113,8 @@ function calculateTradeAcquiredAmounts(direction, amount, market, inputAssetType
     const [newQuoteAssetReserve, newBaseAssetReserve] = (0, amm_1.calculateAmmReservesAfterSwap)(amm, inputAssetType, amount, swapDirection);
     const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
     const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-    const acquiredQuoteAssetamount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
-    return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+    const acquiredQuoteAssetAmount = (0, amm_1.calculateQuoteAssetAmountSwapped)(acquiredQuote.abs(), amm.pegMultiplier, swapDirection);
+    return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 exports.calculateTradeAcquiredAmounts = calculateTradeAcquiredAmounts;
 /**

package/lib/types.d.ts

@@ -203,6 +203,8 @@ export declare type LiquidationRecord = {
     liquidateBorrow: LiquidateBorrowRecord;
     liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
     liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
+    perpBankruptcy: PerpBankruptcyRecord;
+    borrowBankruptcy: BorrowBankruptcyRecord;
 };
 export declare class LiquidationType {
     static readonly LIQUIDATE_PERP: {
@@ -217,6 +219,12 @@ export declare class LiquidationType {
     static readonly LIQUIDATE_PERP_PNL_FOR_DEPOSIT: {
         liquidatePerpPnlForDeposit: {};
     };
+    static readonly PERP_BANKRUPTCY: {
+        perpBankruptcy: {};
+    };
+    static readonly BORROW_BANKRUPTCY: {
+        borrowBankruptcy: {};
+    };
 }
 export declare type LiquidatePerpRecord = {
     marketIndex: BN;
@@ -255,14 +263,25 @@ export declare type LiquidatePerpPnlForDepositRecord = {
     assetPrice: BN;
     assetTransfer: BN;
 };
+export declare type PerpBankruptcyRecord = {
+    marketIndex: BN;
+    pnl: BN;
+    cumulativeFundingRateDelta: BN;
+};
+export declare type BorrowBankruptcyRecord = {
+    bankIndex: BN;
+    borrowAmount: BN;
+    cumulativeDepositInterestDelta: BN;
+};
 export declare type SettlePnlRecord = {
     ts: BN;
+    user: PublicKey;
     marketIndex: BN;
     pnl: BN;
     baseAssetAmount: BN;
     quoteAssetAmountAfter: BN;
     quoteEntryamount: BN;
-    oraclePrice: BN;
+    settlePrice: BN;
 };
 export declare type OrderRecord = {
     ts: BN;
@@ -357,6 +376,10 @@ export declare type BankAccount = {
     maintenanceLiabilityWeight: BN;
     liquidationFee: BN;
     imfFactor: BN;
+    withdrawGuardThreshold: BN;
+    depositTokenTwap: BN;
+    borrowTokenTwap: BN;
+    utilizationTwap: BN;
 };
 export declare type PoolBalance = {
     balance: BN;
@@ -368,8 +391,10 @@ export declare type AMM = {
     lastFundingRate: BN;
     lastFundingRateTs: BN;
     lastMarkPriceTwap: BN;
+    lastMarkPriceTwap5min: BN;
     lastMarkPriceTwapTs: BN;
     lastOraclePriceTwap: BN;
+    lastOraclePriceTwap5min: BN;
     lastOraclePriceTwapTs: BN;
     lastOracleMarkSpreadPct: BN;
     lastOracleConfPct: BN;
@@ -380,11 +405,16 @@ export declare 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;
@@ -406,6 +436,8 @@ export declare type AMM = {
     longSpread: BN;
     shortSpread: BN;
     maxSpread: number;
+    marketPosition: UserPosition;
+    marketPositionPerLp: UserPosition;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
@@ -416,14 +448,20 @@ export declare type UserPosition = {
     openOrders: BN;
     openBids: BN;
     openAsks: BN;
+    realizedPnl: BN;
+    lpShares: BN;
+    lastFeePerLp: BN;
+    lastNetBaseAssetAmountPerLp: BN;
+    lastNetQuoteAssetAmountPerLp: BN;
 };
-export declare type UserAccount = {
-    authority: PublicKey;
-    name: number[];
-    userId: number;
-    bankBalances: UserBankBalance[];
-    collateral: BN;
-    cumulativeDeposits: BN;
+export declare type UserStatsAccount = {
+    numberOfUsers: number;
+    makerVolume30D: BN;
+    takerVolume30D: BN;
+    fillerVolume30D: BN;
+    lastMakerVolume30DTs: BN;
+    lastTakerVolume30DTs: BN;
+    lastFillerVolume30DTs: BN;
     fees: {
         totalFeePaid: BN;
         totalFeeRebate: BN;
@@ -431,9 +469,16 @@ export declare type UserAccount = {
         totalReferralReward: BN;
         totalRefereeDiscount: BN;
     };
+};
+export declare type UserAccount = {
+    authority: PublicKey;
+    name: number[];
+    userId: number;
+    bankBalances: UserBankBalance[];
     positions: UserPosition[];
     orders: Order[];
     beingLiquidated: boolean;
+    bankrupt: boolean;
     nextLiquidationId: number;
 };
 export declare type UserBankBalance = {
@@ -529,10 +574,12 @@ export declare const DefaultOrderParams: {
 };
 export declare type MakerInfo = {
     maker: PublicKey;
+    makerStats: PublicKey;
     order: Order;
 };
 export declare type TakerInfo = {
     taker: PublicKey;
+    takerStats: PublicKey;
     order: Order;
 };
 export interface IWallet {

package/lib/types.js

@@ -108,6 +108,12 @@ LiquidationType.LIQUIDATE_BORROW_FOR_PERP_PNL = {
 LiquidationType.LIQUIDATE_PERP_PNL_FOR_DEPOSIT = {
     liquidatePerpPnlForDeposit: {},
 };
+LiquidationType.PERP_BANKRUPTCY = {
+    perpBankruptcy: {},
+};
+LiquidationType.BORROW_BANKRUPTCY = {
+    borrowBankruptcy: {},
+};
 exports.DefaultOrderParams = {
     orderType: OrderType.MARKET,
     userOrderId: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.13",
+	"version": "0.2.0-master.14",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/fetch.ts

@@ -1,6 +1,9 @@
 import { Connection, PublicKey } from '@solana/web3.js';
-import { UserAccount } from '../types';
-import { getUserAccountPublicKey } from '../addresses/pda';
+import { UserAccount, UserStatsAccount } from '../types';
+import {
+	getUserAccountPublicKey,
+	getUserStatsAccountPublicKey,
+} from '../addresses/pda';
 import { Program } from '@project-serum/anchor';
 
 export async function fetchUserAccounts(
@@ -31,3 +34,25 @@ export async function fetchUserAccounts(
 		) as UserAccount;
 	});
 }
+
+export async function fetchUserStatsAccount(
+	connection: Connection,
+	program: Program,
+	authority: PublicKey
+): Promise<UserStatsAccount | undefined> {
+	const userStatsPublicKey = getUserStatsAccountPublicKey(
+		program.programId,
+		authority
+	);
+	const accountInfo = await connection.getAccountInfo(
+		userStatsPublicKey,
+		'confirmed'
+	);
+
+	return accountInfo
+		? (program.account.user.coder.accounts.decode(
+				'UserStats',
+				accountInfo.data
+		  ) as UserStatsAccount)
+		: undefined;
+}

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -0,0 +1,172 @@
+import {
+	DataAndSlot,
+	AccountToPoll,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { UserStatsAccount } from '../types';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { capitalize } from './utils';
+
+export class PollingUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	accountLoader: BulkAccountLoader;
+	accountsToPoll = new Map<string, AccountToPoll>();
+	errorCallbackId?: string;
+
+	userStats?: DataAndSlot<UserStatsAccount>;
+
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		accountLoader: BulkAccountLoader
+	) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.accountLoader = accountLoader;
+		this.eventEmitter = new EventEmitter();
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		await this.addToAccountLoader();
+
+		let subscriptionSucceeded = false;
+		let retries = 0;
+		while (!subscriptionSucceeded && retries < 5) {
+			await this.fetchIfUnloaded();
+			subscriptionSucceeded = this.didSubscriptionSucceed();
+			retries++;
+		}
+
+		if (subscriptionSucceeded) {
+			this.eventEmitter.emit('update');
+		}
+
+		this.isSubscribed = subscriptionSucceeded;
+		return subscriptionSucceeded;
+	}
+
+	async addToAccountLoader(): Promise<void> {
+		if (this.accountsToPoll.size > 0) {
+			return;
+		}
+
+		this.accountsToPoll.set(this.userStatsAccountPublicKey.toString(), {
+			key: 'userStats',
+			publicKey: this.userStatsAccountPublicKey,
+			eventType: 'userStatsAccountUpdate',
+		});
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			accountToPoll.callbackId = this.accountLoader.addAccount(
+				accountToPoll.publicKey,
+				(buffer, slot) => {
+					if (!buffer) {
+						return;
+					}
+
+					const account = this.program.account[
+						accountToPoll.key
+					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+					this[accountToPoll.key] = { data: account, slot };
+					// @ts-ignore
+					this.eventEmitter.emit(accountToPoll.eventType, account);
+					this.eventEmitter.emit('update');
+				}
+			);
+		}
+
+		this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+			this.eventEmitter.emit('error', error);
+		});
+	}
+
+	async fetchIfUnloaded(): Promise<void> {
+		let shouldFetch = false;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (this[accountToPoll.key] === undefined) {
+				shouldFetch = true;
+				break;
+			}
+		}
+
+		if (shouldFetch) {
+			await this.fetch();
+		}
+	}
+
+	async fetch(): Promise<void> {
+		await this.accountLoader.load();
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+				accountToPoll.publicKey
+			);
+			if (buffer) {
+				const account = this.program.account[
+					accountToPoll.key
+				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+				this[accountToPoll.key] = { data: account, slot };
+			}
+		}
+	}
+
+	didSubscriptionSucceed(): boolean {
+		let success = true;
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			if (!this[accountToPoll.key]) {
+				success = false;
+				break;
+			}
+		}
+		return success;
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		for (const [_, accountToPoll] of this.accountsToPoll) {
+			this.accountLoader.removeAccount(
+				accountToPoll.publicKey,
+				accountToPoll.callbackId
+			);
+		}
+
+		this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+		this.errorCallbackId = undefined;
+
+		this.accountsToPoll.clear();
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStats;
+	}
+}

package/src/accounts/types.ts

@@ -4,6 +4,7 @@ import {
 	OracleSource,
 	StateAccount,
 	UserAccount,
+	UserStatsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -130,3 +131,20 @@ export type DataAndSlot<T> = {
 	data: T;
 	slot: number;
 };
+
+export interface UserStatsAccountEvents {
+	userStatsAccountUpdate: (payload: UserStatsAccount) => void;
+	update: void;
+	error: (e: Error) => void;
+}
+
+export interface UserStatsAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	fetch(): Promise<void>;
+	unsubscribe(): Promise<void>;
+
+	getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount>;
+}

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -0,0 +1,80 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { UserStatsAccount } from '../types';
+
+export class WebSocketUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+
+	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
+			'userStats',
+			this.program,
+			this.userStatsAccountPublicKey
+		);
+		await this.userStatsAccountSubscriber.subscribe(
+			(data: UserStatsAccount) => {
+				this.eventEmitter.emit('userStatsAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStatsAccountSubscriber.dataAndSlot;
+	}
+}

package/src/addresses/pda.ts

@@ -57,6 +57,19 @@ export function getUserAccountPublicKeySync(
 	)[0];
 }
 
+export function getUserStatsAccountPublicKey(
+	programId: PublicKey,
+	authority: PublicKey
+): PublicKey {
+	return anchor.web3.PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+			authority.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
 export async function getMarketPublicKey(
 	programId: PublicKey,
 	marketIndex: BN

package/src/admin.ts

@@ -575,6 +575,35 @@ export class Admin extends ClearingHouse {
 		});
 	}
 
+	public async updateBankWithdrawGuardThreshold(
+		bankIndex: BN,
+		withdrawGuardThreshold: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateBankWithdrawGuardThreshold(
+			withdrawGuardThreshold,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					bank: await getBankPublicKey(this.program.programId, bankIndex),
+				},
+			}
+		);
+	}
+
+	public async updateLpCooldownTime(
+		marketIndex: BN,
+		cooldownTime: BN
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateLpCooldownTime(cooldownTime, {
+			accounts: {
+				admin: this.wallet.publicKey,
+				state: await this.getStatePublicKey(),
+				market: await getMarketPublicKey(this.program.programId, marketIndex),
+			},
+		});
+	}
+
 	public async updateMarketOracle(
 		marketIndex: BN,
 		oracle: PublicKey,
@@ -662,7 +691,6 @@ export class Admin extends ClearingHouse {
 			},
 		});
 	}
-
 	public async updateExchangePaused(
 		exchangePaused: boolean
 	): Promise<TransactionSignature> {