@drift-labs/sdk 0.2.0-master.30 → 0.2.0-master.31

package/src/math/amm.ts

@@ -47,7 +47,7 @@ export function calculateOptimalPegAndBudget(
 	amm: AMM,
 	oraclePriceData: OraclePriceData
 ): [BN, BN, BN, boolean] {
-	const markPriceBefore = calculatePrice(
+	const reservePriceBefore = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
@@ -70,15 +70,15 @@ export function calculateOptimalPegAndBudget(
 		let newTargetPrice: BN;
 		let newOptimalPeg: BN;
 		let newBudget: BN;
-		const targetPriceGap = markPriceBefore.sub(targetPrice);
+		const targetPriceGap = reservePriceBefore.sub(targetPrice);
 
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
 			if (targetPriceGap.lt(new BN(0))) {
-				newTargetPrice = markPriceBefore.add(markAdj);
+				newTargetPrice = reservePriceBefore.add(markAdj);
 			} else {
-				newTargetPrice = markPriceBefore.sub(markAdj);
+				newTargetPrice = reservePriceBefore.sub(markAdj);
 			}
 
 			newOptimalPeg = calculatePegFromTargetPrice(
@@ -336,6 +336,7 @@ export function calculateInventoryScale(
 	minBaseAssetReserve: BN,
 	maxBaseAssetReserve: BN
 ): number {
+	const maxScale = BID_ASK_SPREAD_PRECISION.mul(new BN(10));
 	// inventory skew
 	const [openBids, openAsks] = calculateMarketOpenBidAsk(
 		baseAssetReserve,
@@ -348,10 +349,10 @@ export function calculateInventoryScale(
 		BN.min(openBids.abs(), openAsks.abs())
 	);
 	const inventoryScale =
-		BN.min(netBaseAssetAmount.abs(), minSideLiquidity)
-			.mul(BID_ASK_SPREAD_PRECISION.mul(new BN(10)))
-			.div(minSideLiquidity)
-			.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+		BN.min(
+			maxScale,
+			netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()
+		).toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
 
 	return inventoryScale;
 }
@@ -362,7 +363,7 @@ export function calculateEffectiveLeverage(
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
+	reservePrice: BN,
 	totalFeeMinusDistributions: BN
 ): number {
 	// inventory skew
@@ -372,7 +373,7 @@ export function calculateEffectiveLeverage(
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
 
 	const localBaseAssetValue = netBaseAssetAmount
-		.mul(markPrice)
+		.mul(reservePrice)
 		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
 	const effectiveLeverage =
@@ -393,14 +394,14 @@ export function calculateMaxSpread(marginRatioInitial: number): number {
 
 export function calculateSpreadBN(
 	baseSpread: number,
-	lastOracleMarkSpreadPct: BN,
+	lastOracleReservePriceSpreadPct: BN,
 	lastOracleConfPct: BN,
 	maxSpread: number,
 	quoteAssetReserve: BN,
 	terminalQuoteAssetReserve: BN,
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
-	markPrice: BN,
+	reservePrice: BN,
 	totalFeeMinusDistributions: BN,
 	baseAssetReserve: BN,
 	minBaseAssetReserve: BN,
@@ -409,24 +410,26 @@ export function calculateSpreadBN(
 	let longSpread = baseSpread / 2;
 	let shortSpread = baseSpread / 2;
 
-	if (lastOracleMarkSpreadPct.gt(ZERO)) {
+	if (lastOracleReservePriceSpreadPct.gt(ZERO)) {
 		shortSpread = Math.max(
 			shortSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
-	} else if (lastOracleMarkSpreadPct.lt(ZERO)) {
+	} else if (lastOracleReservePriceSpreadPct.lt(ZERO)) {
 		longSpread = Math.max(
 			longSpread,
-			lastOracleMarkSpreadPct.abs().toNumber() + lastOracleConfPct.toNumber()
+			lastOracleReservePriceSpreadPct.abs().toNumber() +
+				lastOracleConfPct.toNumber()
 		);
 	}
 
 	const maxTargetSpread: number = Math.max(
 		maxSpread,
-		lastOracleMarkSpreadPct.abs().toNumber()
+		lastOracleReservePriceSpreadPct.abs().toNumber()
 	);
 
-	const MAX_INVENTORY_SKEW = 5;
+	const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
 
 	const inventoryScale = calculateInventoryScale(
 		netBaseAssetAmount,
@@ -434,7 +437,10 @@ export function calculateSpreadBN(
 		minBaseAssetReserve,
 		maxBaseAssetReserve
 	);
-	const inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+	const inventorySpreadScale = Math.min(
+		MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+		1 + inventoryScale
+	);
 
 	if (netBaseAssetAmount.gt(ZERO)) {
 		longSpread *= inventorySpreadScale;
@@ -448,20 +454,23 @@ export function calculateSpreadBN(
 		terminalQuoteAssetReserve,
 		pegMultiplier,
 		netBaseAssetAmount,
-		markPrice,
+		reservePrice,
 		totalFeeMinusDistributions
 	);
 
 	if (totalFeeMinusDistributions.gt(ZERO)) {
-		const spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
+		const spreadScale = Math.min(
+			MAX_BID_ASK_INVENTORY_SKEW_FACTOR,
+			1 + effectiveLeverage
+		);
 		if (netBaseAssetAmount.gt(ZERO)) {
 			longSpread *= spreadScale;
 		} else {
 			shortSpread *= spreadScale;
 		}
 	} else {
-		longSpread *= MAX_INVENTORY_SKEW;
-		shortSpread *= MAX_INVENTORY_SKEW;
+		longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+		shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
 	}
 
 	const totalSpread = longSpread + shortSpread;
@@ -487,23 +496,23 @@ export function calculateSpread(
 		return amm.baseSpread / 2;
 	}
 
-	const markPrice = calculatePrice(
+	const reservePrice = calculatePrice(
 		amm.baseAssetReserve,
 		amm.quoteAssetReserve,
 		amm.pegMultiplier
 	);
 
-	const targetPrice = oraclePriceData?.price || markPrice;
+	const targetPrice = oraclePriceData?.price || reservePrice;
 	const confInterval = oraclePriceData.confidence || ZERO;
 
-	const targetMarkSpreadPct = markPrice
+	const targetMarkSpreadPct = reservePrice
 		.sub(targetPrice)
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const confIntervalPct = confInterval
 		.mul(BID_ASK_SPREAD_PRECISION)
-		.div(markPrice);
+		.div(reservePrice);
 
 	const [longSpread, shortSpread] = calculateSpreadBN(
 		amm.baseSpread,
@@ -514,7 +523,7 @@ export function calculateSpread(
 		amm.terminalQuoteAssetReserve,
 		amm.pegMultiplier,
 		amm.netBaseAssetAmount,
-		markPrice,
+		reservePrice,
 		amm.totalFeeMinusDistributions,
 		amm.baseAssetReserve,
 		amm.minBaseAssetReserve,
@@ -684,6 +693,10 @@ export function calculateQuoteAssetAmountSwapped(
 	pegMultiplier: BN,
 	swapDirection: SwapDirection
 ): BN {
+	if (isVariant(swapDirection, 'remove')) {
+		quoteAssetReserves = quoteAssetReserves.add(ONE);
+	}
+
 	let quoteAssetAmount = quoteAssetReserves
 		.mul(pegMultiplier)
 		.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);

package/src/math/market.ts

@@ -106,12 +106,12 @@ export function calculateNewMarketAfterTrade(
 	return newMarket;
 }
 
-export function calculateMarkOracleSpread(
+export function calculateOracleReserveSpread(
 	market: PerpMarketAccount,
 	oraclePriceData: OraclePriceData
 ): BN {
-	const markPrice = calculateReservePrice(market, oraclePriceData);
-	return calculateOracleSpread(markPrice, oraclePriceData);
+	const reservePrice = calculateReservePrice(market, oraclePriceData);
+	return calculateOracleSpread(reservePrice, oraclePriceData);
 }
 
 export function calculateOracleSpread(
@@ -137,7 +137,12 @@ export function calculateMarketMarginRatio(
 			).toNumber();
 			break;
 		case 'Maintenance':
-			marginRatio = market.marginRatioMaintenance;
+			marginRatio = calculateSizePremiumLiabilityWeight(
+				size,
+				market.imfFactor,
+				new BN(market.marginRatioMaintenance),
+				MARGIN_PRECISION
+			).toNumber();
 			break;
 	}
 

package/src/math/spotBalance.ts

@@ -196,22 +196,25 @@ export function calculateInterestRate(bank: SpotMarketAccount): BN {
 	const utilization = calculateUtilization(bank);
 
 	let interestRate: BN;
-	if (utilization.gt(bank.optimalUtilization)) {
-		const surplusUtilization = utilization.sub(bank.optimalUtilization);
-		const borrowRateSlope = bank.maxBorrowRate
-			.sub(bank.optimalBorrowRate)
+	if (utilization.gt(new BN(bank.optimalUtilization))) {
+		const surplusUtilization = utilization.sub(new BN(bank.optimalUtilization));
+		const borrowRateSlope = new BN(bank.maxBorrowRate - bank.optimalBorrowRate)
 			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
-			.div(SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+			.div(
+				SPOT_MARKET_UTILIZATION_PRECISION.sub(new BN(bank.optimalUtilization))
+			);
 
-		interestRate = bank.optimalBorrowRate.add(
+		interestRate = new BN(bank.optimalBorrowRate).add(
 			surplusUtilization
 				.mul(borrowRateSlope)
 				.div(SPOT_MARKET_UTILIZATION_PRECISION)
 		);
 	} else {
-		const borrowRateSlope = bank.optimalBorrowRate
+		const borrowRateSlope = new BN(bank.optimalBorrowRate)
 			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
-			.div(SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+			.div(
+				SPOT_MARKET_UTILIZATION_PRECISION.sub(new BN(bank.optimalUtilization))
+			);
 
 		interestRate = utilization
 			.mul(borrowRateSlope)

package/src/math/trade.ts

@@ -215,20 +215,20 @@ export function calculateTargetPriceTrade(
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateReservePrice(market, oraclePriceData);
+	const reservePriceBefore = calculateReservePrice(market, oraclePriceData);
 	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
 	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
 	let direction;
-	if (targetPrice.gt(markPriceBefore)) {
-		const priceGap = targetPrice.sub(markPriceBefore);
+	if (targetPrice.gt(reservePriceBefore)) {
+		const priceGap = targetPrice.sub(reservePriceBefore);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-		targetPrice = markPriceBefore.add(priceGapScaled);
+		targetPrice = reservePriceBefore.add(priceGapScaled);
 		direction = PositionDirection.LONG;
 	} else {
-		const priceGap = markPriceBefore.sub(targetPrice);
+		const priceGap = reservePriceBefore.sub(targetPrice);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-		targetPrice = markPriceBefore.sub(priceGapScaled);
+		targetPrice = reservePriceBefore.sub(priceGapScaled);
 		direction = PositionDirection.SHORT;
 	}
 
@@ -265,14 +265,14 @@ export function calculateTargetPriceTrade(
 		targetPrice.gt(bidPriceBefore)
 	) {
 		// no trade, market is at target
-		if (markPriceBefore.gt(targetPrice)) {
+		if (reservePriceBefore.gt(targetPrice)) {
 			direction = PositionDirection.SHORT;
 		} else {
 			direction = PositionDirection.LONG;
 		}
 		tradeSize = ZERO;
 		return [direction, tradeSize, targetPrice, targetPrice];
-	} else if (markPriceBefore.gt(targetPrice)) {
+	} else if (reservePriceBefore.gt(targetPrice)) {
 		// overestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)
@@ -291,7 +291,7 @@ export function calculateTargetPriceTrade(
 			.div(PEG_PRECISION)
 			.div(AMM_TO_QUOTE_PRECISION_RATIO);
 		baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
-	} else if (markPriceBefore.lt(targetPrice)) {
+	} else if (reservePriceBefore.lt(targetPrice)) {
 		// underestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).add(biasModifier)
@@ -320,12 +320,12 @@ export function calculateTargetPriceTrade(
 
 	let tp1 = targetPrice;
 	let tp2 = markPriceAfter;
-	let originalDiff = targetPrice.sub(markPriceBefore);
+	let originalDiff = targetPrice.sub(reservePriceBefore);
 
 	if (direction == PositionDirection.SHORT) {
 		tp1 = markPriceAfter;
 		tp2 = targetPrice;
-		originalDiff = markPriceBefore.sub(targetPrice);
+		originalDiff = reservePriceBefore.sub(targetPrice);
 	}
 
 	const entryPrice = tradeSize

package/src/types.ts

@@ -3,8 +3,23 @@ import { BN, ZERO } from '.';
 
 // # Utility Types / Enums / Constants
 
+export class ExchangeStatus {
+	static readonly ACTIVE = { active: {} };
+	static readonly FUNDINGPAUSED = { fundingpaused: {} };
+	static readonly AMMPAUSED = { ammpaused: {} };
+	static readonly FILLPAUSED = { fillpaused: {} };
+	static readonly LIQPAUSED = { liqpaused: {} };
+	static readonly WITHDRAWPAUSED = { withdrawpaused: {} };
+	static readonly PAUSED = { paused: {} };
+}
+
 export class MarketStatus {
 	static readonly INITIALIZED = { initialized: {} };
+	static readonly ACTIVE = { active: {} };
+	static readonly FUNDINGPAUSED = { fundingpaused: {} };
+	static readonly AMMPAUSED = { ammpaused: {} };
+	static readonly FILLPAUSED = { fillpaused: {} };
+	static readonly WITHDRAWPAUSED = { withdrawpaused: {} };
 	static readonly REDUCEONLY = { reduceonly: {} };
 	static readonly SETTLEMENT = { settlement: {} };
 	static readonly DELISTED = { delisted: {} };
@@ -15,6 +30,21 @@ export class ContractType {
 	static readonly FUTURE = { future: {} };
 }
 
+export class ContractTier {
+	static readonly A = { a: {} };
+	static readonly B = { b: {} };
+	static readonly C = { c: {} };
+	static readonly Speculative = { speculative: {} };
+}
+
+export class AssetTier {
+	static readonly COLLATERAL = { collateral: {} };
+	static readonly PROTECTED = { protected: {} };
+	static readonly CROSS = { cross: {} };
+	static readonly ISOLATED = { isolated: {} };
+	static readonly UNLISTED = { unlisted: {} };
+}
+
 export class SwapDirection {
 	static readonly ADD = { add: {} };
 	static readonly REMOVE = { remove: {} };
@@ -155,9 +185,23 @@ export type DepositRecord = {
 	marketIndex: number;
 	amount: BN;
 	oraclePrice: BN;
-	referrer: PublicKey;
-	from?: PublicKey;
-	to?: PublicKey;
+	marketDepositBalance: BN;
+	marketWithdrawBalance: BN;
+	marketCumulativeDepositInterest: BN;
+	marketCumulativeBorrowInterest: BN;
+	transferUser?: PublicKey;
+};
+
+export type SpotInterestRecord = {
+	ts: BN;
+	marketIndex: number;
+	depositBalance: BN;
+	cumulativeDepositInterest: BN;
+	borrowBalance: BN;
+	cumulativeBorrowInterest: BN;
+	optimalUtilization: number;
+	optimalBorrowRate: number;
+	maxBorrowRate: number;
 };
 
 export type CurveRecord = {
@@ -184,8 +228,8 @@ export declare type InsuranceFundRecord = {
 	ts: BN;
 	bankIndex: BN;
 	marketIndex: number;
-	userIfFactor: BN;
-	totalIfFactor: BN;
+	userIfFactor: number;
+	totalIfFactor: number;
 	vaultAmountBefore: BN;
 	insuranceVaultAmountBefore: BN;
 	amount: BN;
@@ -234,7 +278,6 @@ export type FundingPaymentRecord = {
 	fundingPayment: BN;
 	baseAssetAmount: BN;
 	userLastCumulativeFunding: BN;
-	userLastFundingRateTs: BN;
 	ammCumulativeFundingLong: BN;
 	ammCumulativeFundingShort: BN;
 };
@@ -249,11 +292,11 @@ export type LiquidationRecord = {
 	liquidationId: number;
 	canceledOrderIds: BN[];
 	liquidatePerp: LiquidatePerpRecord;
-	liquidateBorrow: LiquidateBorrowRecord;
+	liquidateSpot: LiquidateSpotRecord;
 	liquidateBorrowForPerpPnl: LiquidateBorrowForPerpPnlRecord;
 	liquidatePerpPnlForDeposit: LiquidatePerpPnlForDepositRecord;
 	perpBankruptcy: PerpBankruptcyRecord;
-	borrowBankruptcy: BorrowBankruptcyRecord;
+	spotBankruptcy: SpotBankruptcyRecord;
 };
 
 export class LiquidationType {
@@ -279,15 +322,13 @@ export type LiquidatePerpRecord = {
 	baseAssetAmount: BN;
 	quoteAssetAmount: BN;
 	lpShares: BN;
-	userPnl: BN;
-	liquidatorPnl: BN;
 	userOrderId: BN;
 	liquidatorOrderId: BN;
 	fillRecordId: BN;
 	ifFee: BN;
 };
 
-export type LiquidateBorrowRecord = {
+export type LiquidateSpotRecord = {
 	assetMarketIndex: number;
 	assetPrice: BN;
 	assetTransfer: BN;
@@ -321,7 +362,7 @@ export type PerpBankruptcyRecord = {
 	cumulativeFundingRateDelta: BN;
 };
 
-export type BorrowBankruptcyRecord = {
+export type SpotBankruptcyRecord = {
 	marketIndex: number;
 	borrowAmount: BN;
 	cumulativeDepositInterestDelta: BN;
@@ -360,14 +401,14 @@ export type OrderActionRecord = {
 	referrerReward: number | null;
 	quoteAssetAmountSurplus: BN | null;
 	taker: PublicKey | null;
-	takerOrderId: BN | null;
+	takerOrderId: number | null;
 	takerOrderDirection: PositionDirection | null;
 	takerOrderBaseAssetAmount: BN | null;
 	takerOrderCumulativeBaseAssetAmountFilled: BN | null;
 	takerOrderCumulativeQuoteAssetAmountFilled: BN | null;
 	takerOrderFee: BN | null;
 	maker: PublicKey | null;
-	makerOrderId: BN | null;
+	makerOrderId: number | null;
 	makerOrderDirection: PositionDirection | null;
 	makerOrderBaseAssetAmount: BN | null;
 	makerOrderCumulativeBaseAssetAmountFilled: BN | null;
@@ -378,24 +419,20 @@ export type OrderActionRecord = {
 
 export type StateAccount = {
 	admin: PublicKey;
-	fundingPaused: boolean;
-	exchangePaused: boolean;
-	adminControlsPrices: boolean;
-	totalFee: BN;
-	totalFeeWithdrawn: BN;
+	exchangeStatus: ExchangeStatus;
 	whitelistMint: PublicKey;
 	discountMint: PublicKey;
 	oracleGuardRails: OracleGuardRails;
-	maxDeposit: BN;
 	numberOfMarkets: number;
 	numberOfSpotMarkets: number;
 	minOrderQuoteAssetAmount: BN;
-	signer: PublicKey;
-	signerNonce: number;
-	defaultMarketOrderTimeInForce: number;
 	minPerpAuctionDuration: number;
+	defaultMarketOrderTimeInForce: number;
 	defaultSpotAuctionDuration: number;
 	liquidationMarginBufferRatio: number;
+	settlementDuration: number;
+	signer: PublicKey;
+	signerNonce: number;
 	srmVault: PublicKey;
 	perpFeeStructure: FeeStructure;
 	spotFeeStructure: FeeStructure;
@@ -449,6 +486,9 @@ export type HistoricalIndexData = {
 };
 
 export type SpotMarketAccount = {
+	status: MarketStatus;
+	assetTier: AssetTier;
+
 	marketIndex: number;
 	pubkey: PublicKey;
 	mint: PublicKey;
@@ -466,18 +506,20 @@ export type SpotMarketAccount = {
 	totalIfShares: BN;
 	userIfShares: BN;
 
-	userIfFactor: BN;
-	totalIfFactor: BN;
+	userIfFactor: number;
+	totalIfFactor: number;
 	ifLiquidationFee: BN;
 
 	decimals: number;
-	optimalUtilization: BN;
-	optimalBorrowRate: BN;
-	maxBorrowRate: BN;
+	optimalUtilization: number;
+	optimalBorrowRate: number;
+	maxBorrowRate: number;
 	cumulativeDepositInterest: BN;
 	cumulativeBorrowInterest: BN;
 	depositBalance: BN;
 	borrowBalance: BN;
+	maxTokenDeposits: BN;
+
 	lastInterestTs: BN;
 	lastTwapTs: BN;
 	initialAssetWeight: BN;
@@ -494,14 +536,13 @@ export type SpotMarketAccount = {
 
 	orderStepSize: BN;
 	nextFillRecordId: BN;
-	spotFeePool: {
-		balance: BN;
-	};
+	spotFeePool: PoolBalance;
 	totalSpotFee: BN;
 };
 
 export type PoolBalance = {
 	balance: BN;
+	marketIndex: number;
 };
 
 export type AMM = {
@@ -518,7 +559,7 @@ export type AMM = {
 	oracleSource: OracleSource;
 	historicalOracleData: HistoricalOracleData;
 
-	lastOracleMarkSpreadPct: BN;
+	lastOracleReservePriceSpreadPct: BN;
 	lastOracleConfPct: BN;
 
 	fundingPeriod: BN;
@@ -567,7 +608,6 @@ export type AMM = {
 // # User Account Types
 export type PerpPosition = {
 	baseAssetAmount: BN;
-	remainderBaseAssetAmount: BN;
 	lastCumulativeFundingRate: BN;
 	marketIndex: number;
 	quoteAssetAmount: BN;
@@ -577,7 +617,7 @@ export type PerpPosition = {
 	openAsks: BN;
 	settledPnl: BN;
 	lpShares: BN;
-	lastFeePerLp: BN;
+	remainderBaseAssetAmount: number;
 	lastNetBaseAssetAmountPerLp: BN;
 	lastNetQuoteAssetAmountPerLp: BN;
 };
@@ -614,7 +654,7 @@ export type UserAccount = {
 	beingLiquidated: boolean;
 	bankrupt: boolean;
 	nextLiquidationId: number;
-	nextOrderId: BN;
+	nextOrderId: number;
 	customMarginRatio: number;
 };
 
@@ -634,7 +674,7 @@ export type Order = {
 	marketType: MarketType;
 	ts: BN;
 	slot: BN;
-	orderId: BN;
+	orderId: number;
 	userOrderId: number;
 	marketIndex: number;
 	price: BN;
@@ -669,10 +709,10 @@ export type OrderParams = {
 	reduceOnly: boolean;
 	postOnly: boolean;
 	immediateOrCancel: boolean;
-	triggerPrice: BN;
+	triggerPrice: BN | null;
 	triggerCondition: OrderTriggerCondition;
 	positionLimit: BN;
-	oraclePriceOffset: BN;
+	oraclePriceOffset: BN | null;
 	auctionDuration: number | null;
 	timeInForce: number | null;
 	auctionStartPrice: BN | null;
@@ -700,10 +740,10 @@ export const DefaultOrderParams = {
 	reduceOnly: false,
 	postOnly: false,
 	immediateOrCancel: false,
-	triggerPrice: ZERO,
+	triggerPrice: null,
 	triggerCondition: OrderTriggerCondition.ABOVE,
 	positionLimit: ZERO,
-	oraclePriceOffset: ZERO,
+	oraclePriceOffset: null,
 	auctionDuration: null,
 	timeInForce: null,
 	auctionStartPrice: null,
@@ -712,6 +752,7 @@ export const DefaultOrderParams = {
 export type MakerInfo = {
 	maker: PublicKey;
 	makerStats: PublicKey;
+	makerUserAccount: UserAccount;
 	order: Order;
 };
 

package/tests/bn/test.ts

@@ -77,6 +77,8 @@ describe('BigNum Tests', () => {
 		expect(val.toPrecision(5)).to.equal('1234.5');
 		expect(val.toPrecision(11)).to.equal('1234.5678900');
 
+		expect(BigNum.from('1234').toPrecision(5)).to.equal('1234.0');
+
 		// Case 2
 		const val2 = BigNum.from(1, 5);
 
@@ -99,8 +101,8 @@ describe('BigNum Tests', () => {
 			.shift(AMM_RESERVE_PRECISION_EXP)
 			.div(BigNum.from(entryPriceNum * 10 ** 8));
 
-		expect(val4.toString()).to.equal('250000000000');
-		expect(val4.print()).to.equal('0.0250000000000');
+		expect(val4.toString()).to.equal('25000000');
+		expect(val4.print()).to.equal('0.025000000');
 		expect(val4.toNum().toFixed(3)).to.equal('0.025');
 		expect(val4.toPrecision(4)).to.equal('0.025');
 
@@ -118,8 +120,8 @@ describe('BigNum Tests', () => {
 		expect(BigNum.fromPrint('1').toMillified(5)).to.equal('1.0000');
 		expect(BigNum.fromPrint('12').toMillified(5)).to.equal('12.000');
 		expect(BigNum.fromPrint('123').toMillified(5)).to.equal('123.00');
-		expect(BigNum.fromPrint('1234').toMillified(5)).to.equal('1.2340K');
-		expect(BigNum.fromPrint('12345').toMillified(5)).to.equal('12.345K');
+		expect(BigNum.fromPrint('1234').toMillified(5)).to.equal('1234.0');
+		expect(BigNum.fromPrint('12345').toMillified(5)).to.equal('12345');
 		expect(BigNum.fromPrint('123456').toMillified(5)).to.equal('123.45K');
 		expect(BigNum.fromPrint('1234567').toMillified(5)).to.equal('1.2345M');
 		expect(BigNum.fromPrint('12345678').toMillified(5)).to.equal('12.345M');
@@ -142,8 +144,8 @@ describe('BigNum Tests', () => {
 		const baseAmountVal1 = '14.33';
 		const val1 = BigNum.fromPrint(baseAmountVal1, BASE_PRECISION_EXP);
 
-		expect(val1.toString()).to.equal('143300000000000');
-		expect(val1.print()).to.equal('14.3300000000000');
+		expect(val1.toString()).to.equal('14330000000');
+		expect(val1.print()).to.equal('14.330000000');
 
 		const baseAmountVal2 = '34.1';
 		const val2 = BigNum.fromPrint(baseAmountVal2, BASE_PRECISION_EXP);
@@ -225,7 +227,7 @@ describe('BigNum Tests', () => {
 			.shift(AMM_RESERVE_PRECISION_EXP)
 			.div(BigNum.from(entryPriceNum * 10 ** 8));
 
-		expect(val.toString()).to.equal('250000000000');
+		expect(val.toString()).to.equal('25000000');
 		expect(val.printShort()).to.equal('0.025');
 
 		const val2 = BigNum.from(10000, 4);
@@ -260,5 +262,8 @@ describe('BigNum Tests', () => {
 
 		const val9 = BigNum.from('1000000000123', 6);
 		expect(val9.prettyPrint()).to.equal('1,000,000.000123');
+
+		const val10 = BigNum.from('100000000000', 6);
+		expect(val10.prettyPrint(true)).to.equal('100,000');
 	});
 });