@drift-labs/sdk 0.2.0-master.26 → 0.2.0-master.28

package/src/math/orders.ts

@@ -131,9 +131,9 @@ export function standardizeBaseAssetAmount(
 
 export function getLimitPrice(
 	order: Order,
-	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number
+	slot: number,
+	perpMarket?: PerpMarketAccount
 ): BN {
 	let limitPrice;
 	if (!order.oraclePriceOffset.eq(ZERO)) {
@@ -143,14 +143,26 @@ export function getLimitPrice(
 			limitPrice = getAuctionPrice(order, slot);
 		} else if (!order.price.eq(ZERO)) {
 			limitPrice = order.price;
-		} else if (isVariant(order.direction, 'long')) {
-			const askPrice = calculateAskPrice(market, oraclePriceData);
-			const delta = askPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = askPrice.add(delta);
 		} else {
-			const bidPrice = calculateBidPrice(market, oraclePriceData);
-			const delta = bidPrice.div(new BN(market.amm.maxSlippageRatio));
-			limitPrice = bidPrice.sub(delta);
+			if (perpMarket) {
+				if (isVariant(order.direction, 'long')) {
+					const askPrice = calculateAskPrice(perpMarket, oraclePriceData);
+					const delta = askPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
+					limitPrice = askPrice.add(delta);
+				} else {
+					const bidPrice = calculateBidPrice(perpMarket, oraclePriceData);
+					const delta = bidPrice.div(new BN(perpMarket.amm.maxSlippageRatio));
+					limitPrice = bidPrice.sub(delta);
+				}
+			} else {
+				// check oracle validity?
+				const oraclePrice1Pct = oraclePriceData.price.div(new BN(100));
+				if (isVariant(order.direction, 'long')) {
+					limitPrice = oraclePriceData.price.add(oraclePrice1Pct);
+				} else {
+					limitPrice = oraclePriceData.price.sub(oraclePrice1Pct);
+				}
+			}
 		}
 	} else {
 		limitPrice = order.price;
@@ -163,8 +175,7 @@ export function isFillableByVAMM(
 	order: Order,
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData,
-	slot: number,
-	maxAuctionDuration: number
+	slot: number
 ): boolean {
 	return (
 		(isAuctionComplete(order, slot) &&
@@ -174,7 +185,7 @@ export function isFillableByVAMM(
 				oraclePriceData,
 				slot
 			).eq(ZERO)) ||
-		isOrderExpired(order, slot, maxAuctionDuration)
+		isOrderExpired(order, slot)
 	);
 }
 
@@ -191,7 +202,7 @@ export function calculateBaseAssetAmountForAmmToFulfill(
 		return ZERO;
 	}
 
-	const limitPrice = getLimitPrice(order, market, oraclePriceData, slot);
+	const limitPrice = getLimitPrice(order, oraclePriceData, slot, market);
 	const baseAssetAmount = calculateBaseAssetAmountToFillUpToLimitPrice(
 		order,
 		market,
@@ -246,17 +257,14 @@ function isSameDirection(
 	);
 }
 
-export function isOrderExpired(
-	order: Order,
-	slot: number,
-	maxAuctionDuration: number
-): boolean {
+export function isOrderExpired(order: Order, slot: number): boolean {
 	if (
-		!isVariant(order.orderType, 'market') ||
-		!isVariant(order.status, 'open')
+		isOneOfVariant(order.orderType, ['triggerMarket', 'triggerLimit']) ||
+		!isVariant(order.status, 'open') ||
+		order.timeInForce === 0
 	) {
 		return false;
 	}
 
-	return new BN(slot).sub(order.slot).gt(new BN(maxAuctionDuration));
+	return new BN(slot).sub(order.slot).gt(new BN(order.timeInForce));
 }

package/src/math/position.ts

@@ -1,4 +1,4 @@
-import { BN } from '../';
+import { BN, SpotMarketAccount } from '../';
 import {
 	AMM_RESERVE_PRECISION,
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
@@ -17,8 +17,8 @@ import {
 	calculateAmmReservesAfterSwap,
 	getSwapDirection,
 } from './amm';
-
 import { calculateBaseAssetValueWithOracle } from './margin';
+import { calculateNetUserPnlImbalance } from './market';
 
 /**
  * calculateBaseAssetValue
@@ -31,7 +31,9 @@ import { calculateBaseAssetValueWithOracle } from './margin';
 export function calculateBaseAssetValue(
 	market: PerpMarketAccount,
 	userPosition: PerpPosition,
-	oraclePriceData: OraclePriceData
+	oraclePriceData: OraclePriceData,
+	useSpread = true,
+	skipUpdate = false
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
@@ -40,21 +42,25 @@ export function calculateBaseAssetValue(
 	const directionToClose = findDirectionToClose(userPosition);
 	let prepegAmm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 
-	if (market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
-			calculateUpdatedAMMSpreadReserves(
-				market.amm,
-				directionToClose,
-				oraclePriceData
-			);
-		prepegAmm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: sqrtK,
-			pegMultiplier: newPeg,
-		};
+	if (!skipUpdate) {
+		if (market.amm.baseSpread > 0 && useSpread) {
+			const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+				calculateUpdatedAMMSpreadReserves(
+					market.amm,
+					directionToClose,
+					oraclePriceData
+				);
+			prepegAmm = {
+				baseAssetReserve,
+				quoteAssetReserve,
+				sqrtK: sqrtK,
+				pegMultiplier: newPeg,
+			};
+		} else {
+			prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+		}
 	} else {
-		prepegAmm = calculateUpdatedAMM(market.amm, oraclePriceData);
+		prepegAmm = market.amm;
 	}
 
 	const [newQuoteAssetReserve, _] = calculateAmmReservesAfterSwap(
@@ -124,8 +130,9 @@ export function calculatePositionPNL(
 	return pnl;
 }
 
-export function calculateUnsettledPnl(
+export function calculateClaimablePnl(
 	market: PerpMarketAccount,
+	spotMarket: SpotMarketAccount,
 	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
@@ -136,16 +143,23 @@ export function calculateUnsettledPnl(
 		oraclePriceData
 	);
 
-	let unsettledPnl = unrealizedPnl;
+	const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(
+		PRICE_TO_QUOTE_PRECISION
+	);
+
+	let unsettledPnl = unrealizedPnl.add(fundingPnL);
 	if (unrealizedPnl.gt(ZERO)) {
-		const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(
-			PRICE_TO_QUOTE_PRECISION
+		const excessPnlPool = BN.max(
+			ZERO,
+			calculateNetUserPnlImbalance(market, spotMarket, oraclePriceData).mul(
+				new BN(-1)
+			)
 		);
 
 		const maxPositivePnl = BN.max(
 			perpPosition.quoteAssetAmount
 				.sub(perpPosition.quoteEntryAmount)
-				.add(fundingPnL),
+				.add(excessPnlPool),
 			ZERO
 		);
 

package/src/math/repeg.ts

@@ -98,6 +98,15 @@ export function calculateBudgetedKBN(
 		.div(QUOTE_PRECISION);
 	const denom2 = pegged_y_d_d;
 
+	// protocol is spending to increase k
+	if (C.lt(ZERO)) {
+		// thus denom1 is negative and solution is unstable
+		if (denom1.lt(pegged_y_d_d.abs())) {
+			console.log('budget cost exceeds stable K solution');
+			return [new BN(10000), new BN(1)];
+		}
+	}
+
 	const numerator = numer1.sub(numer2).div(AMM_TO_QUOTE_PRECISION_RATIO);
 	const denominator = denom1.add(denom2).div(AMM_TO_QUOTE_PRECISION_RATIO);
 

package/src/math/spotBalance.ts

@@ -19,6 +19,7 @@ import {
 	calculateSizeDiscountAssetWeight,
 	calculateSizePremiumLiabilityWeight,
 } from './margin';
+import { OraclePriceData } from '../oracles/types';
 
 export function getBalance(
 	tokenAmount: BN,
@@ -54,6 +55,31 @@ export function getTokenAmount(
 	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
 }
 
+export function getSignedTokenAmount(
+	tokenAmount: BN,
+	balanceType: SpotBalanceType
+): BN {
+	if (isVariant(balanceType, 'deposit')) {
+		return tokenAmount;
+	} else {
+		return tokenAmount.abs().neg();
+	}
+}
+
+export function getTokenValue(
+	tokenAmount: BN,
+	spotDecimals: number,
+	oraclePriceData: OraclePriceData
+): BN {
+	if (tokenAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const precisionDecrease = TEN.pow(new BN(10 + spotDecimals - 6));
+
+	return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
+}
+
 export function calculateAssetWeight(
 	balanceAmount: BN,
 	spotMarket: SpotMarketAccount,

package/src/math/spotPosition.ts

@@ -1,6 +1,47 @@
-import { SpotPosition } from '../types';
+import { SpotMarketAccount, SpotPosition } from '../types';
 import { ZERO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import {
+	getSignedTokenAmount,
+	getTokenAmount,
+	getTokenValue,
+} from './spotBalance';
+import { OraclePriceData } from '../oracles/types';
 
 export function isSpotPositionAvailable(position: SpotPosition): boolean {
 	return position.balance.eq(ZERO) && position.openOrders === 0;
 }
+
+export function getWorstCaseTokenAmounts(
+	spotPosition: SpotPosition,
+	spotMarketAccount: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const tokenAmount = getSignedTokenAmount(
+		getTokenAmount(
+			spotPosition.balance,
+			spotMarketAccount,
+			spotPosition.balanceType
+		),
+		spotPosition.balanceType
+	);
+
+	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+
+	if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openBids.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+	} else {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openAsks.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+	}
+}

package/src/types.ts

@@ -7,6 +7,7 @@ export class MarketStatus {
 	static readonly INITIALIZED = { initialized: {} };
 	static readonly REDUCEONLY = { reduceonly: {} };
 	static readonly SETTLEMENT = { settlement: {} };
+	static readonly DELISTED = { delisted: {} };
 }
 
 export class ContractType {
@@ -47,6 +48,7 @@ export class OrderType {
 	static readonly MARKET = { market: {} };
 }
 
+export declare type MarketTypeStr = 'perp' | 'spot';
 export class MarketType {
 	static readonly SPOT = { spot: {} };
 	static readonly PERP = { perp: {} };
@@ -113,6 +115,10 @@ export function isOneOfVariant(object: unknown, types: string[]) {
 	}, false);
 }
 
+export function getVariant(object: unknown): string {
+	return Object.keys(object)[0];
+}
+
 export enum TradeSide {
 	None = 0,
 	Buy = 1,
@@ -241,6 +247,7 @@ export type LiquidationRecord = {
 	marginRequirement: BN;
 	totalCollateral: BN;
 	liquidationId: number;
+	canceledOrderIds: BN[];
 	liquidatePerp: LiquidatePerpRecord;
 	liquidateBorrow: LiquidateBorrowRecord;
 	liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
@@ -268,17 +275,16 @@ export class LiquidationType {
 
 export type LiquidatePerpRecord = {
 	marketIndex: BN;
-	orderIds: BN[];
 	oraclePrice: BN;
 	baseAssetAmount: BN;
 	quoteAssetAmount: BN;
 	lpShares: BN;
 	userPnl: BN;
 	liquidatorPnl: BN;
-	canceledOrdersFee: BN;
 	userOrderId: BN;
 	liquidatorOrderId: BN;
 	fillRecordId: BN;
+	ifFee: BN;
 };
 
 export type LiquidateBorrowRecord = {
@@ -288,6 +294,7 @@ export type LiquidateBorrowRecord = {
 	liabilityMarketIndex: BN;
 	liabilityPrice: BN;
 	liabilityTransfer: BN;
+	ifFee: BN;
 };
 
 export type LiquidateBorrowForPerpPnlRecord = {
@@ -378,17 +385,6 @@ export type StateAccount = {
 	exchangePaused: boolean;
 	adminControlsPrices: boolean;
 	insuranceVault: PublicKey;
-	marginRatioInitial: BN;
-	marginRatioMaintenance: BN;
-	marginRatioPartial: BN;
-	partialLiquidationClosePercentageNumerator: BN;
-	partialLiquidationClosePercentageDenominator: BN;
-	partialLiquidationPenaltyPercentageNumerator: BN;
-	partialLiquidationPenaltyPercentageDenominator: BN;
-	fullLiquidationPenaltyPercentageNumerator: BN;
-	fullLiquidationPenaltyPercentageDenominator: BN;
-	partialLiquidationLiquidatorShareDenominator: BN;
-	fullLiquidationLiquidatorShareDenominator: BN;
 	perpFeeStructure: FeeStructure;
 	spotFeeStructure: FeeStructure;
 	totalFee: BN;
@@ -402,8 +398,9 @@ export type StateAccount = {
 	minOrderQuoteAssetAmount: BN;
 	signer: PublicKey;
 	signerNonce: number;
-	maxAuctionDuration: number;
-	minAuctionDuration: number;
+	defaultMarketOrderTimeInForce: number;
+	minPerpAuctionDuration: number;
+	defaultSpotAuctionDuration: number;
 	liquidationMarginBufferRatio: number;
 };
 
@@ -423,7 +420,8 @@ export type PerpMarketAccount = {
 	marginRatioMaintenance: number;
 	nextFillRecordId: BN;
 	pnlPool: PoolBalance;
-	liquidationFee: BN;
+	liquidatorFee: BN;
+	ifLiquidationFee: BN;
 	imfFactor: BN;
 	unrealizedImfFactor: BN;
 	unrealizedMaxImbalance: BN;
@@ -451,7 +449,7 @@ export type SpotMarketAccount = {
 
 	userIfFactor: BN;
 	totalIfFactor: BN;
-	liquidationIfFactor: BN;
+	ifLiquidationFee: BN;
 
 	decimals: number;
 	optimalUtilization: BN;
@@ -468,7 +466,7 @@ export type SpotMarketAccount = {
 	maintenanceAssetWeight: BN;
 	initialLiabilityWeight: BN;
 	maintenanceLiabilityWeight: BN;
-	liquidationFee: BN;
+	liquidatorFee: BN;
 	imfFactor: BN;
 
 	withdrawGuardThreshold: BN;
@@ -561,7 +559,7 @@ export type PerpPosition = {
 	openOrders: BN;
 	openBids: BN;
 	openAsks: BN;
-	realizedPnl: BN;
+	settledPnl: BN;
 	lpShares: BN;
 	lastFeePerLp: BN;
 	lastNetBaseAssetAmountPerLp: BN;
@@ -600,6 +598,7 @@ export type UserAccount = {
 	bankrupt: boolean;
 	nextLiquidationId: number;
 	nextOrderId: BN;
+	customMarginRatio: number;
 };
 
 export type SpotPosition = {
@@ -638,6 +637,7 @@ export type Order = {
 	auctionDuration: number;
 	auctionStartPrice: BN;
 	auctionEndPrice: BN;
+	timeInForce: number;
 };
 
 export type OrderParams = {
@@ -655,8 +655,9 @@ export type OrderParams = {
 	triggerCondition: OrderTriggerCondition;
 	positionLimit: BN;
 	oraclePriceOffset: BN;
-	padding0: boolean;
-	padding1: BN;
+	auctionDuration: number | null;
+	timeInForce: number | null;
+	auctionStartPrice: BN | null;
 };
 
 export type NecessaryOrderParams = {
@@ -685,8 +686,9 @@ export const DefaultOrderParams = {
 	triggerCondition: OrderTriggerCondition.ABOVE,
 	positionLimit: ZERO,
 	oraclePriceOffset: ZERO,
-	padding0: ZERO,
-	padding1: ZERO,
+	auctionDuration: null,
+	timeInForce: null,
+	auctionStartPrice: null,
 };
 
 export type MakerInfo = {
@@ -748,7 +750,7 @@ export type FeeStructure = {
 	makerRebateNumerator: BN;
 	makerRebateDenominator: BN;
 	fillerRewardStructure: OrderFillerRewardStructure;
-	cancelOrderFee: BN;
+	flatFillerFee: BN;
 };
 
 export type OracleGuardRails = {

package/src/userMap/userMap.ts

@@ -0,0 +1,100 @@
+import {
+	ClearingHouseUser,
+	ClearingHouse,
+	UserAccount,
+	bulkPollingUserSubscribe,
+	OrderRecord,
+	ClearingHouseUserAccountSubscriptionConfig,
+} from '..';
+import { ProgramAccount } from '@project-serum/anchor';
+
+import { PublicKey } from '@solana/web3.js';
+
+export class UserMap {
+	private userMap = new Map<string, ClearingHouseUser>();
+	private clearingHouse: ClearingHouse;
+	private accountSubscription: ClearingHouseUserAccountSubscriptionConfig;
+
+	constructor(
+		clearingHouse: ClearingHouse,
+		accountSubscription: ClearingHouseUserAccountSubscriptionConfig
+	) {
+		this.clearingHouse = clearingHouse;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUsers() {
+		const userArray: ClearingHouseUser[] = [];
+
+		const programUserAccounts =
+			(await this.clearingHouse.program.account.user.all()) as ProgramAccount<UserAccount>[];
+		for (const programUserAccount of programUserAccounts) {
+			if (this.userMap.has(programUserAccount.publicKey.toString())) {
+				continue;
+			}
+
+			const user = new ClearingHouseUser({
+				clearingHouse: this.clearingHouse,
+				userAccountPublicKey: programUserAccount.publicKey,
+				accountSubscription: this.accountSubscription,
+			});
+			userArray.push(user);
+		}
+
+		if (this.accountSubscription.type === 'polling') {
+			await bulkPollingUserSubscribe(
+				userArray,
+				this.accountSubscription.accountLoader
+			);
+		}
+
+		for (const user of userArray) {
+			this.userMap.set(user.getUserAccountPublicKey().toString(), user);
+		}
+	}
+
+	public async addPubkey(userAccountPublicKey: PublicKey) {
+		const user = new ClearingHouseUser({
+			clearingHouse: this.clearingHouse,
+			userAccountPublicKey,
+			accountSubscription: this.accountSubscription,
+		});
+		await user.subscribe();
+		this.userMap.set(userAccountPublicKey.toString(), user);
+	}
+
+	public has(key: string): boolean {
+		return this.userMap.has(key);
+	}
+
+	/**
+	 * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, undefined is returned
+	 * @param key userAccountPublicKey to get ClearngHouseUserFor
+	 * @returns user ClearingHouseUser | undefined
+	 */
+	public get(key: string): ClearingHouseUser | undefined {
+		return this.userMap.get(key);
+	}
+
+	/**
+	 * gets the ClearingHouseUser for a particular userAccountPublicKey, if no ClearingHouseUser exists, new one is created
+	 * @param key userAccountPublicKey to get ClearngHouseUserFor
+	 * @returns  ClearingHouseUser
+	 */
+	public async mustGet(key: string): Promise<ClearingHouseUser> {
+		if (!this.has(key)) {
+			await this.addPubkey(new PublicKey(key));
+		}
+		const user = this.userMap.get(key);
+		await user.fetchAccounts();
+		return user;
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord) {
+		await this.addPubkey(record.user);
+	}
+
+	public values(): IterableIterator<ClearingHouseUser> {
+		return this.userMap.values();
+	}
+}

package/src/userMap/userStatsMap.ts

@@ -0,0 +1,110 @@
+import {
+	ClearingHouse,
+	getUserStatsAccountPublicKey,
+	OrderRecord,
+	UserStatsAccount,
+	ClearingHouseUserStats,
+	ClearingHouseUserStatsAccountSubscriptionConfig,
+	bulkPollingUserStatsSubscribe,
+} from '..';
+import { ProgramAccount } from '@project-serum/anchor';
+import { PublicKey } from '@solana/web3.js';
+
+import { UserMap } from './userMap';
+
+export class UserStatsMap {
+	/**
+	 * map from authority pubkey to ClearingHouseUserStats
+	 */
+	private userStatsMap = new Map<string, ClearingHouseUserStats>();
+	private clearingHouse: ClearingHouse;
+	private accountSubscription: ClearingHouseUserStatsAccountSubscriptionConfig;
+
+	constructor(
+		clearingHouse: ClearingHouse,
+		accountSubscription: ClearingHouseUserStatsAccountSubscriptionConfig
+	) {
+		this.clearingHouse = clearingHouse;
+		this.accountSubscription = accountSubscription;
+	}
+
+	public async fetchAllUserStats() {
+		const userStatArray: ClearingHouseUserStats[] = [];
+
+		const programUserAccounts =
+			(await this.clearingHouse.program.account.userStats.all()) as ProgramAccount<UserStatsAccount>[];
+
+		for (const programUserAccount of programUserAccounts) {
+			const userStat: UserStatsAccount = programUserAccount.account;
+			if (this.userStatsMap.has(userStat.authority.toString())) {
+				continue;
+			}
+
+			const chUserStat = new ClearingHouseUserStats({
+				clearingHouse: this.clearingHouse,
+				userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+					this.clearingHouse.program.programId,
+					userStat.authority
+				),
+				accountSubscription: this.accountSubscription,
+			});
+			userStatArray.push(chUserStat);
+		}
+
+		if (this.accountSubscription.type === 'polling') {
+			await bulkPollingUserStatsSubscribe(
+				userStatArray,
+				this.accountSubscription.accountLoader
+			);
+		}
+
+		for (const userStat of userStatArray) {
+			this.userStatsMap.set(
+				userStat.getAccount().authority.toString(),
+				userStat
+			);
+		}
+	}
+
+	public async addUserStat(authority: PublicKey) {
+		const userStat = new ClearingHouseUserStats({
+			clearingHouse: this.clearingHouse,
+			userStatsAccountPublicKey: getUserStatsAccountPublicKey(
+				this.clearingHouse.program.programId,
+				authority
+			),
+			accountSubscription: this.accountSubscription,
+		});
+		await userStat.subscribe();
+
+		this.userStatsMap.set(authority.toString(), userStat);
+	}
+
+	public async updateWithOrderRecord(record: OrderRecord, userMap: UserMap) {
+		if (!this.has(record.user.toString())) {
+			const takerUserAccount = await userMap.mustGet(record.user.toString());
+			this.addUserStat(takerUserAccount.getUserAccount().authority);
+		}
+	}
+
+	public has(authorityPublicKey: string): boolean {
+		return this.userStatsMap.has(authorityPublicKey);
+	}
+
+	public get(authorityPublicKey: string): ClearingHouseUserStats {
+		return this.userStatsMap.get(authorityPublicKey);
+	}
+
+	public async mustGet(
+		authorityPublicKey: string
+	): Promise<ClearingHouseUserStats> {
+		if (!this.has(authorityPublicKey)) {
+			await this.addUserStat(new PublicKey(authorityPublicKey));
+		}
+		return this.get(authorityPublicKey);
+	}
+
+	public values(): IterableIterator<ClearingHouseUserStats> {
+		return this.userStatsMap.values();
+	}
+}