@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.2

package/src/types.ts

@@ -7,6 +7,11 @@ export class SwapDirection {
 	static readonly REMOVE = { remove: {} };
 }
 
+export class BankBalanceType {
+	static readonly DEPOSIT = { deposit: {} };
+	static readonly BORROW = { borrow: {} };
+}
+
 export class PositionDirection {
 	static readonly LONG = { long: {} };
 	static readonly SHORT = { short: {} };
@@ -15,6 +20,7 @@ export class PositionDirection {
 export class OracleSource {
 	static readonly PYTH = { pyth: {} };
 	static readonly SWITCHBOARD = { switchboard: {} };
+	static readonly QUOTE_ASSET = { quoteAsset: {} };
 }
 
 export class OrderType {
@@ -42,6 +48,7 @@ export class OrderAction {
 	static readonly CANCEL = { cancel: {} };
 	static readonly EXPIRE = { expire: {} };
 	static readonly FILL = { fill: {} };
+	static readonly TRIGGER = { trigger: {} };
 }
 
 export class OrderTriggerCondition {
@@ -53,6 +60,12 @@ export function isVariant(object: unknown, type: string) {
 	return object.hasOwnProperty(type);
 }
 
+export function isOneOfVariant(object: unknown, types: string[]) {
+	return types.reduce((result, type) => {
+		return result || object.hasOwnProperty(type);
+	}, false);
+}
+
 export enum TradeSide {
 	None = 0,
 	Buy = 1,
@@ -69,58 +82,21 @@ export type CandleResolution =
 	| 'W'
 	| 'M';
 
-// # ClearingHouse Account Types
-export type TradeHistoryAccount = {
-	head: BN;
-	tradeRecords: TradeRecord[];
-};
-
-export type DepositHistoryAccount = {
-	head: BN;
-	depositRecords: DepositRecord[];
-};
-
-export type ExtendedCurveHistoryAccount = {
-	head: BN;
-	curveRecords: ExtendedCurveRecord[];
-};
-
-export type FundingRateHistoryAccount = {
-	head: BN;
-	fundingRateRecords: FundingRateRecord[];
-};
-
-export type FundingPaymentHistoryAccount = {
-	head: BN;
-	fundingPaymentRecords: FundingPaymentRecord[];
-};
-
-export type LiquidationHistoryAccount = {
-	head: BN;
-	liquidationRecords: LiquidationRecord[];
-};
-
-export type OrderHistoryAccount = {
-	head: BN;
-	lastOrderId: BN;
-	orderRecords: OrderRecord[];
-};
-
 export type DepositRecord = {
 	ts: BN;
-	recordId: BN;
 	userAuthority: PublicKey;
 	user: PublicKey;
 	direction: {
 		deposit?: any;
 		withdraw?: any;
 	};
-	collateralBefore: BN;
-	cumulativeDepositsBefore: BN;
+	bankIndex: BN;
 	amount: BN;
+	from?: PublicKey;
+	to?: PublicKey;
 };
 
-export type ExtendedCurveRecord = {
+export type CurveRecord = {
 	ts: BN;
 	recordId: BN;
 	marketIndex: BN;
@@ -140,28 +116,6 @@ export type ExtendedCurveRecord = {
 	tradeId: BN;
 };
 
-export type TradeRecord = {
-	ts: BN;
-	recordId: BN;
-	userAuthority: PublicKey;
-	user: PublicKey;
-	direction: {
-		long?: any;
-		short?: any;
-	};
-	baseAssetAmount: BN;
-	quoteAssetAmount: BN;
-	markPriceBefore: BN;
-	markPriceAfter: BN;
-	fee: BN;
-	quoteAssetAmountSurplus: BN;
-	refereeDiscount: BN;
-	tokenDiscount: BN;
-	marketIndex: BN;
-	liquidation: boolean;
-	oraclePrice: BN;
-};
-
 export type FundingRateRecord = {
 	ts: BN;
 	recordId: BN;
@@ -175,7 +129,6 @@ export type FundingRateRecord = {
 
 export type FundingPaymentRecord = {
 	ts: BN;
-	recordId: BN;
 	userAuthority: PublicKey;
 	user: PublicKey;
 	marketIndex: BN;
@@ -207,18 +160,21 @@ export type LiquidationRecord = {
 
 export type OrderRecord = {
 	ts: BN;
-	recordId: BN;
-	order: Order;
-	user: PublicKey;
-	authority: PublicKey;
+	taker: PublicKey;
+	maker: PublicKey;
+	takerOrder: Order;
+	makerOrder: Order;
 	action: OrderAction;
 	filler: PublicKey;
+	fillRecordId: BN;
+	marketIndex: BN;
 	baseAssetAmountFilled: BN;
 	quoteAssetAmountFilled: BN;
-	fee: BN;
+	makerRebate: BN;
+	takerFee: BN;
 	fillerReward: BN;
-	tradeRecordId: BN;
 	quoteAssetAmountSurplus: BN;
+	oraclePrice: BN;
 };
 
 export type StateAccount = {
@@ -226,23 +182,12 @@ export type StateAccount = {
 	fundingPaused: boolean;
 	exchangePaused: boolean;
 	adminControlsPrices: boolean;
-	collateralMint: PublicKey;
-	collateralVault: PublicKey;
-	collateralVaultAuthority: PublicKey;
-	collateralVaultNonce: number;
 	insuranceVault: PublicKey;
 	insuranceVaultAuthority: PublicKey;
 	insuranceVaultNonce: number;
 	marginRatioInitial: BN;
 	marginRatioMaintenance: BN;
 	marginRatioPartial: BN;
-	markets: PublicKey;
-	curveHistory: PublicKey;
-	depositHistory: PublicKey;
-	fundingRateHistory: PublicKey;
-	fundingPaymentHistory: PublicKey;
-	tradeHistory: PublicKey;
-	liquidationHistory: PublicKey;
 	partialLiquidationClosePercentageNumerator: BN;
 	partialLiquidationClosePercentageDenominator: BN;
 	partialLiquidationPenaltyPercentageNumerator: BN;
@@ -258,37 +203,52 @@ export type StateAccount = {
 	discountMint: PublicKey;
 	oracleGuardRails: OracleGuardRails;
 	maxDeposit: BN;
-	orderState: PublicKey;
-	extendedCurveHistory: PublicKey;
-};
-
-export type OrderStateAccount = {
-	orderHistory: PublicKey;
-	orderFillerRewardStructure: OrderFillerRewardStructure;
+	numberOfMarkets: BN;
+	numberOfBanks: BN;
 	minOrderQuoteAssetAmount: BN;
 };
 
-export type SettlementStateAccount = {
-	totalSettlementValue: BN;
-	collateralAvailableToClaim: BN;
-	collateralClaimed: BN;
-	enabled: boolean;
-};
-
-export type MarketsAccount = {
-	markets: Market[];
-};
-
-export type Market = {
+export type MarketAccount = {
+	initialized: boolean;
+	marketIndex: BN;
+	pubkey: PublicKey;
 	amm: AMM;
 	baseAssetAmount: BN;
 	baseAssetAmountLong: BN;
 	baseAssetAmountShort: BN;
-	initialized: boolean;
 	openInterest: BN;
 	marginRatioInitial: number;
 	marginRatioMaintenance: number;
 	marginRatioPartial: number;
+	nextFillRecordId: BN;
+	pnlPool: PoolBalance;
+};
+
+export type BankAccount = {
+	bankIndex: BN;
+	pubkey: PublicKey;
+	mint: PublicKey;
+	vault: PublicKey;
+	vaultAuthority: PublicKey;
+	vaultAuthorityNonce: number;
+	decimals: number;
+	optimalUtilization: BN;
+	optimalBorrowRate: BN;
+	maxBorrowRate: BN;
+	cumulativeDepositInterest: BN;
+	cumulativeBorrowInterest: BN;
+	depositBalance: BN;
+	borrowBalance: BN;
+	lastUpdated: BN;
+	oracle: PublicKey;
+	initialAssetWeight: BN;
+	maintenanceAssetWeight: BN;
+	initialLiabilityWeight: BN;
+	maintenanceLiabilityWeight: BN;
+};
+
+export type PoolBalance = {
+	balance: BN;
 };
 
 export type AMM = {
@@ -314,9 +274,24 @@ export type AMM = {
 	totalFeeWithdrawn: BN;
 	totalFee: BN;
 	minimumQuoteAssetTradeSize: BN;
-	minimumBaseAssetTradeSize: BN;
+	baseAssetAmountStepSize: BN;
 	lastOraclePrice: BN;
 	baseSpread: number;
+	curveUpdateIntensity: number;
+	netBaseAssetAmount: BN;
+	quoteAssetAmountLong: BN;
+	quoteAssetAmountShort: BN;
+	terminalQuoteAssetReserve: BN;
+	feePool: PoolBalance;
+	totalExchangeFee: BN;
+	totalMmFee: BN;
+	netRevenueSinceLastFunding: BN;
+	lastUpdateSlot: BN;
+	lastBidPriceTwap: BN;
+	lastAskPriceTwap: BN;
+	longSpread: BN;
+	shortSpread: BN;
+	maxSpread: number;
 };
 
 // # User Account Types
@@ -325,45 +300,46 @@ export type UserPosition = {
 	lastCumulativeFundingRate: BN;
 	marketIndex: BN;
 	quoteAssetAmount: BN;
+	quoteEntryAmount: BN;
 	openOrders: BN;
-};
-
-export type UserPositionsAccount = {
-	positions: UserPosition[];
-	user: PublicKey;
+	unsettledPnl: BN;
+	openBids: BN;
+	openAsks: BN;
 };
 
 export type UserAccount = {
 	authority: PublicKey;
+	name: number[];
+	userId: number;
+	bankBalances: UserBankBalance[];
 	collateral: BN;
 	cumulativeDeposits: BN;
-	positions: PublicKey;
-	totalFeePaid: BN;
-	totalFeeRebate: BN;
-	totalTokenDiscount: BN;
-	totalReferralReward: BN;
-	totalRefereeDiscount: BN;
-	settledPositionValue: BN;
-	collateralClaimed: BN;
-	lastCollateralAvailableToClaim: BN;
-	forgoPositionSettlement: number;
-	hasSettledPosition: number;
+	fees: {
+		totalFeePaid: BN;
+		totalFeeRebate: BN;
+		totalTokenDiscount: BN;
+		totalReferralReward: BN;
+		totalRefereeDiscount: BN;
+	};
+	positions: UserPosition[];
+	orders: Order[];
 };
 
-export type UserOrdersAccount = {
-	orders: Order[];
-	user: PublicKey;
+export type UserBankBalance = {
+	bankIndex: BN;
+	balanceType: BankBalanceType;
+	balance: BN;
 };
 
 export type Order = {
 	status: OrderStatus;
 	orderType: OrderType;
 	ts: BN;
+	slot: BN;
 	orderId: BN;
 	userOrderId: number;
 	marketIndex: BN;
 	price: BN;
-	userBaseAssetAmount: BN;
 	baseAssetAmount: BN;
 	baseAssetAmountFilled: BN;
 	quoteAssetAmount: BN;
@@ -373,11 +349,16 @@ export type Order = {
 	reduceOnly: boolean;
 	triggerPrice: BN;
 	triggerCondition: OrderTriggerCondition;
+	triggered: boolean;
 	discountTier: OrderDiscountTier;
+	existingPositionDirection: PositionDirection;
 	referrer: PublicKey;
 	postOnly: boolean;
 	immediateOrCancel: boolean;
 	oraclePriceOffset: BN;
+	auctionDuration: number;
+	auctionStartPrice: BN;
+	auctionEndPrice: BN;
 };
 
 export type OrderParams = {
@@ -403,6 +384,11 @@ export type OrderParams = {
 	};
 };
 
+export type MakerInfo = {
+	maker: PublicKey;
+	order: Order;
+};
+
 // # Misc Types
 export interface IWallet {
 	signTransaction(tx: Transaction): Promise<Transaction>;
@@ -441,6 +427,9 @@ export type FeeStructure = {
 		refereeDiscountNumerator: BN;
 		refereeDiscountDenominator: BN;
 	};
+	makerRebateNumerator: BN;
+	makerRebateDenominator: BN;
+	fillerRewardStructure: OrderFillerRewardStructure;
 };
 
 export type OracleGuardRails = {

package/src/userName.ts

@@ -0,0 +1,20 @@
+export const MAX_NAME_LENGTH = 32;
+
+export const DEFAULT_USER_NAME = 'Main Account';
+
+export function encodeName(name: string): number[] {
+	if (name.length > MAX_NAME_LENGTH) {
+		throw Error(`User name (${name}) longer than 32 characters`);
+	}
+
+	const buffer = Buffer.alloc(32);
+	buffer.fill(name);
+	buffer.fill(' ', name.length);
+
+	return Array(...buffer);
+}
+
+export function decodeName(bytes: number[]): string {
+	const buffer = Buffer.from(bytes);
+	return buffer.toString('utf8').trim();
+}

package/src/util/computeUnits.js

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1 @@
+{"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"}

package/tests/bn/test.ts

@@ -0,0 +1,255 @@
+import { BN } from '@project-serum/anchor';
+import { expect } from 'chai';
+import { BigNum } from '../../src/factory/bigNum';
+import {
+	AMM_RESERVE_PRECISION_EXP,
+	BASE_PRECISION_EXP,
+	TEN_THOUSAND,
+} from '../../src/constants/numericConstants';
+// if you used the '@types/mocha' method to install mocha type definitions, uncomment the following line
+// import 'mocha';
+
+describe('BigNum Tests', () => {
+	it('basic string representations are correct', () => {
+		const bn = BigNum.from(TEN_THOUSAND);
+		expect(bn.toString()).to.equal('10000');
+		expect(bn.print()).to.equal('10000');
+
+		const bn2 = BigNum.from(TEN_THOUSAND, new BN(4));
+		expect(bn2.toString()).to.equal('10000');
+		expect(bn2.print()).to.equal('1.0000');
+
+		const bn3 = BigNum.from(new BN('123456789'), new BN(4));
+		expect(bn3.toString()).to.equal('123456789');
+		expect(bn3.print()).to.equal('12345.6789');
+	});
+
+	it('can do basic maths correctly', () => {
+		const val1 = BigNum.from(10 ** 4, 2).mul(BigNum.from(123456));
+
+		expect(val1.toString()).to.equal('1234560000');
+
+		// should trim one point of precision off
+		const val2 = val1.div(BigNum.from(10 ** 5));
+
+		expect(val2.toString()).to.equal('12345');
+		expect(val2.print()).to.equal('123.45');
+
+		// Trying to represent a 33.33333333% figure to precision 4
+		const baseNumberPrecision = 10;
+		const adjustmentPrecision = 4;
+
+		const currentNumber = 400 * 10 ** baseNumberPrecision;
+		const comparisonNumber = 300 * 10 ** baseNumberPrecision;
+
+		const val3 = BigNum.from(currentNumber, baseNumberPrecision)
+			.sub(BigNum.from(comparisonNumber, baseNumberPrecision))
+			.mul(BigNum.from(10 ** adjustmentPrecision, adjustmentPrecision))
+			.mul(BigNum.from(100))
+			.div(BigNum.from(comparisonNumber, baseNumberPrecision))
+			.abs();
+
+		expect(val3.toString()).to.equal('333333');
+		expect(val3.print()).to.equal('33.3333');
+	});
+
+	it('can shift numbers correctly', () => {
+		const val1 = BigNum.from(new BN(`319657850313098510000000000`), 23).shift(
+			new BN(-10)
+		);
+
+		expect(val1.toString()).to.equal(`31965785031309851`);
+		expect(val1.print()).to.equal(`3196.5785031309851`);
+	});
+
+	it('can print numbers correctly', () => {
+		// Case 1
+		const val = BigNum.from(123456789, 5);
+
+		expect(val.toString()).to.equal('123456789');
+
+		expect(val.print()).to.equal('1234.56789');
+
+		expect(val.toFixed(3)).to.equal('1234.567');
+
+		expect(val.toPrecision(1)).to.equal('1e3');
+		expect(val.toPrecision(3)).to.equal('123e1');
+		expect(val.toPrecision(4)).to.equal('1234');
+		expect(val.toPrecision(5)).to.equal('1234.5');
+		expect(val.toPrecision(11)).to.equal('1234.5678900');
+
+		// Case 2
+		const val2 = BigNum.from(1, 5);
+
+		expect(val2.toString()).to.equal('1');
+
+		expect(val2.print()).to.equal('0.00001');
+
+		// Case 3
+		const val3 = BigNum.from(101003, 5);
+
+		expect(val3.toString()).to.equal('101003');
+
+		expect(val3.print()).to.equal('1.01003');
+		expect(val3.toPrecision(7)).to.equal('1.010030');
+
+		// Case 4
+		const rawQuoteValue = 1;
+		const entryPriceNum = 40;
+		const val4 = BigNum.from(rawQuoteValue * 10 ** 8)
+			.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.toFixed(3)).to.equal('0.025');
+		expect(val4.toPrecision(4)).to.equal('0.025');
+
+		// Case 5
+		expect(BigNum.fromPrint('1').toMillified()).to.equal('1.00');
+		expect(BigNum.fromPrint('12').toMillified()).to.equal('12.0');
+		expect(BigNum.fromPrint('123').toMillified()).to.equal('123');
+		expect(BigNum.fromPrint('1234').toMillified()).to.equal('1.23K');
+		expect(BigNum.fromPrint('12345').toMillified()).to.equal('12.3K');
+		expect(BigNum.fromPrint('123456').toMillified()).to.equal('123K');
+		expect(BigNum.fromPrint('1234567').toMillified()).to.equal('1.23M');
+		expect(BigNum.fromPrint('12345678').toMillified()).to.equal('12.3M');
+		expect(BigNum.fromPrint('123456789').toMillified()).to.equal('123M');
+
+		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('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');
+		expect(BigNum.fromPrint('123456789').toMillified(5)).to.equal('123.45M');
+	});
+
+	it('can initialise from string values correctly', () => {
+		// Case 1
+
+		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');
+
+		const baseAmountVal2 = '34.1';
+		const val2 = BigNum.fromPrint(baseAmountVal2, BASE_PRECISION_EXP);
+
+		expect(val2.printShort()).to.equal('34.1');
+	});
+
+	it('is immutable', () => {
+		// Case 1
+		const initVal = BigNum.from(1);
+		const postShift = initVal.shift(new BN(10), true);
+		const postScale = postShift.scale(1, 10 ** 10);
+
+		expect(initVal.toString()).to.equal(postScale.toString());
+		expect(initVal === postShift).to.equal(false);
+		expect(initVal.val === postShift.val).to.equal(false);
+		expect(initVal === postScale).to.equal(false);
+		expect(initVal.val === postScale.val).to.equal(false);
+		expect(postShift === postScale).to.equal(false);
+		expect(postShift.val === postScale.val).to.equal(false);
+
+		const postMul = postScale.mul(new BN(1000));
+		const postDiv = postMul.div(new BN(1000));
+
+		expect(postMul.toString()).to.equal('1000');
+		expect(postDiv.toString()).to.equal('1');
+		expect(postMul === postDiv).to.equal(false);
+		expect(postMul.val === postDiv.val).to.equal(false);
+
+		const postAdd = postDiv.add(BigNum.from(new BN(1000)));
+		const postSub = postAdd.sub(BigNum.from(new BN(1000)));
+
+		expect(postAdd.toString()).to.equal('1001');
+		expect(postSub.toString()).to.equal('1');
+		expect(postAdd === postSub).to.equal(false);
+		expect(postAdd.val === postSub.val).to.equal(false);
+	});
+
+	it('serializes properly', () => {
+		// JSON
+		let val = BigNum.from(new BN('123456'), 3);
+		expect(val.toString()).to.equal('123456');
+		val = val.shift(new BN(3));
+		expect(val.toString()).to.equal('123456000');
+		expect(val.print()).to.equal('123.456000');
+
+		const stringified = JSON.stringify(val);
+
+		expect(stringified).to.equal('{"val":"123456000","precision":"6"}');
+
+		let parsed = BigNum.fromJSON(JSON.parse(stringified));
+		expect(parsed.toString()).to.equal('123456000');
+		expect(parsed.print()).to.equal('123.456000');
+
+		parsed = parsed.shift(new BN(3));
+		expect(parsed.toString()).to.equal('123456000000');
+		expect(parsed.print()).to.equal('123.456000000');
+	});
+
+	it('can convert to a percentage', () => {
+		// JSON
+		const val = BigNum.from(new BN('100000'), 3);
+		const val2 = BigNum.from(new BN('200000'), 3);
+		const val3 = BigNum.from(new BN('66666'), 3);
+		const val4 = BigNum.from(new BN('50000'), 3);
+		const val5 = BigNum.from(new BN('700000'), 3);
+
+		expect(val.toPercentage(val2, 3)).to.equal('50.0');
+		expect(val.toPercentage(val2, 4)).to.equal('50.00');
+		expect(val3.toPercentage(val2, 4)).to.equal('33.33');
+		expect(val4.toPercentage(val2, 4)).to.equal('25.00');
+		expect(val.toPercentage(val5, 6)).to.equal('14.2857');
+	});
+
+	it('can print without unnecessary trailing zeroes', () => {
+		const rawQuoteValue = 1;
+		const entryPriceNum = 40;
+		const val = BigNum.from(rawQuoteValue * 10 ** 8)
+			.shift(AMM_RESERVE_PRECISION_EXP)
+			.div(BigNum.from(entryPriceNum * 10 ** 8));
+
+		expect(val.toString()).to.equal('250000000000');
+		expect(val.printShort()).to.equal('0.025');
+
+		const val2 = BigNum.from(10000, 4);
+		expect(val2.print()).to.equal('1.0000');
+		expect(val2.printShort()).to.equal('1');
+	});
+
+	it('can pretty print', () => {
+		const val = BigNum.from('123');
+		expect(val.prettyPrint()).to.equal('123');
+
+		const val2 = BigNum.from('1234');
+		expect(val2.prettyPrint()).to.equal('1,234');
+
+		const val3 = BigNum.from('123456');
+		expect(val3.prettyPrint()).to.equal('123,456');
+
+		const val4 = BigNum.from('1234567');
+		expect(val4.prettyPrint()).to.equal('1,234,567');
+
+		const val5 = BigNum.from('12345678');
+		expect(val5.prettyPrint()).to.equal('12,345,678');
+
+		const val6 = BigNum.from('123456', 3);
+		expect(val6.prettyPrint()).to.equal('123.456');
+
+		const val7 = BigNum.from('123456789', 3);
+		expect(val7.prettyPrint()).to.equal('123,456.789');
+
+		const val8 = BigNum.from('1000000000000', 6);
+		expect(val8.prettyPrint()).to.equal('1,000,000');
+
+		const val9 = BigNum.from('1000000000123', 6);
+		expect(val9.prettyPrint()).to.equal('1,000,000.000123');
+	});
+});