@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/src/examples/makeTradeExample.ts

@@ -3,17 +3,19 @@ import { Wallet } from '..';
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
-	calculateMarkPrice,
-	ClearingHouse,
-	ClearingHouseUser,
+	calculateReservePrice,
+	DriftClient,
+	User,
 	initialize,
 	PositionDirection,
 	convertToNumber,
 	calculateTradeSlippage,
-	MARK_PRICE_PRECISION,
+	BulkAccountLoader,
+	PerpMarkets,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
 } from '..';
-import { Banks } from '../constants/banks';
+import { SpotMarkets } from '../constants/spotMarkets';
 
 export const getTokenAddress = (
 	mintAddress: string,
@@ -27,9 +29,11 @@ export const getTokenAddress = (
 	);
 };
 
+const cluster = 'devnet';
+
 const main = async () => {
 	// Initialize Drift SDK
-	const sdkConfig = initialize({ env: 'devnet' });
+	const sdkConfig = initialize({ env: cluster });
 
 	// Set up the Wallet and Provider
 	const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
@@ -60,20 +64,35 @@ const main = async () => {
 	);
 
 	// Set up the Drift Clearing House
-	const clearingHousePublicKey = new PublicKey(
-		sdkConfig.CLEARING_HOUSE_PROGRAM_ID
+	const driftPublicKey = new PublicKey(sdkConfig.DRIFT_PROGRAM_ID);
+	const bulkAccountLoader = new BulkAccountLoader(
+		connection,
+		'confirmed',
+		1000
 	);
-	const clearingHouse = new ClearingHouse({
+	const driftClient = new DriftClient({
 		connection,
 		wallet: provider.wallet,
-		programID: clearingHousePublicKey,
+		programID: driftPublicKey,
+		perpMarketIndexes: PerpMarkets[cluster].map((market) => market.marketIndex),
+		spotMarketIndexes: SpotMarkets[cluster].map(
+			(spotMarket) => spotMarket.marketIndex
+		),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
 	});
-	await clearingHouse.subscribe();
+	await driftClient.subscribe();
 
 	// Set up Clearing House user client
-	const user = new ClearingHouseUser({
-		clearingHouse,
-		userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+	const user = new User({
+		driftClient: driftClient,
+		userAccountPublicKey: await driftClient.getUserAccountPublicKey(),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
 	});
 
 	//// Check if clearing house account exists for the current wallet
@@ -82,37 +101,34 @@ const main = async () => {
 	if (!userAccountExists) {
 		//// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
 		const depositAmount = new BN(10000).mul(QUOTE_PRECISION);
-		await clearingHouse.initializeUserAccountAndDepositCollateral(
+		await driftClient.initializeUserAccountAndDepositCollateral(
 			depositAmount,
 			await getTokenAddress(
 				usdcTokenAddress.toString(),
 				wallet.publicKey.toString()
 			),
-			Banks['devnet'][0].bankIndex
+			SpotMarkets['devnet'][0].marketIndex
 		);
 	}
 
 	await user.subscribe();
 
 	// Get current price
-	const solMarketInfo = sdkConfig.MARKETS.find(
+	const solMarketInfo = sdkConfig.PERP_MARKETS.find(
 		(market) => market.baseAssetSymbol === 'SOL'
 	);
 
-	const currentMarketPrice = calculateMarkPrice(
-		clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
+	const currentMarketPrice = calculateReservePrice(
+		driftClient.getPerpMarketAccount(solMarketInfo.marketIndex),
 		undefined
 	);
 
-	const formattedPrice = convertToNumber(
-		currentMarketPrice,
-		MARK_PRICE_PRECISION
-	);
+	const formattedPrice = convertToNumber(currentMarketPrice, PRICE_PRECISION);
 
 	console.log(`Current Market Price is $${formattedPrice}`);
 
 	// Estimate the slippage for a $5000 LONG trade
-	const solMarketAccount = clearingHouse.getMarketAccount(
+	const solMarketAccount = driftClient.getPerpMarketAccount(
 		solMarketInfo.marketIndex
 	);
 
@@ -125,7 +141,7 @@ const main = async () => {
 			'quote',
 			undefined
 		)[0],
-		MARK_PRICE_PRECISION
+		PRICE_PRECISION
 	);
 
 	console.log(
@@ -133,7 +149,7 @@ const main = async () => {
 	);
 
 	// Make a $5000 LONG trade
-	await clearingHouse.openPosition(
+	await driftClient.openPosition(
 		PositionDirection.LONG,
 		longAmount,
 		solMarketInfo.marketIndex
@@ -142,14 +158,14 @@ const main = async () => {
 
 	// Reduce the position by $2000
 	const reduceAmount = new BN(2000).mul(QUOTE_PRECISION);
-	await clearingHouse.openPosition(
+	await driftClient.openPosition(
 		PositionDirection.SHORT,
 		reduceAmount,
 		solMarketInfo.marketIndex
 	);
 
 	// Close the rest of the position
-	await clearingHouse.closePosition(solMarketInfo.marketIndex);
+	await driftClient.closePosition(solMarketInfo.marketIndex);
 };
 
 main();

package/src/factory/bigNum.ts

@@ -9,6 +9,11 @@ export class BigNum {
 	static delim = '.';
 	static spacer = ',';
 
+	public static setLocale(locale: string): void {
+		BigNum.delim = (1.1).toLocaleString(locale).slice(1, 2) || '.';
+		BigNum.spacer = (1000).toLocaleString(locale).slice(1, 2) || ',';
+	}
+
 	constructor(
 		val: BN | number | string,
 		precisionVal: BN | number | string = new BN(0)
@@ -17,6 +22,10 @@ export class BigNum {
 		this.precision = new BN(precisionVal);
 	}
 
+	private bigNumFromParam(bn: BigNum | BN) {
+		return BN.isBN(bn) ? BigNum.from(bn) : bn;
+	}
+
 	public add(bn: BigNum): BigNum {
 		assert(bn.precision.eq(this.precision), 'Adding unequal precisions');
 
@@ -30,7 +39,7 @@ export class BigNum {
 	}
 
 	public mul(bn: BigNum | BN): BigNum {
-		const mulVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const mulVal = this.bigNumFromParam(bn);
 
 		return BigNum.from(
 			this.val.mul(mulVal.val),
@@ -44,7 +53,7 @@ export class BigNum {
 	 * @returns
 	 */
 	public scalarMul(bn: BigNum | BN): BigNum {
-		if (bn instanceof BN) return BigNum.from(this.val.mul(bn), this.precision);
+		if (BN.isBN(bn)) return BigNum.from(this.val.mul(bn), this.precision);
 
 		return BigNum.from(
 			this.val.mul(bn.val),
@@ -53,7 +62,8 @@ export class BigNum {
 	}
 
 	public div(bn: BigNum | BN): BigNum {
-		if (bn instanceof BN) return BigNum.from(this.val.div(bn), this.precision);
+		if (BN.isBN(bn)) return BigNum.from(this.val.div(bn), this.precision);
+
 		return BigNum.from(this.val.div(bn.val), this.precision.sub(bn.precision));
 	}
 
@@ -101,7 +111,7 @@ export class BigNum {
 	}
 
 	public gt(bn: BigNum | BN, ignorePrecision?: boolean): boolean {
-		const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const comparisonVal = this.bigNumFromParam(bn);
 
 		if (!ignorePrecision && !comparisonVal.eq(ZERO)) {
 			assert(
@@ -114,7 +124,7 @@ export class BigNum {
 	}
 
 	public lt(bn: BigNum | BN, ignorePrecision?: boolean): boolean {
-		const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const comparisonVal = this.bigNumFromParam(bn);
 
 		if (!ignorePrecision && !comparisonVal.val.eq(ZERO)) {
 			assert(
@@ -127,7 +137,7 @@ export class BigNum {
 	}
 
 	public gte(bn: BigNum | BN, ignorePrecision?: boolean): boolean {
-		const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const comparisonVal = this.bigNumFromParam(bn);
 
 		if (!ignorePrecision && !comparisonVal.val.eq(ZERO)) {
 			assert(
@@ -140,7 +150,7 @@ export class BigNum {
 	}
 
 	public lte(bn: BigNum | BN, ignorePrecision?: boolean): boolean {
-		const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const comparisonVal = this.bigNumFromParam(bn);
 
 		if (!ignorePrecision && !comparisonVal.val.eq(ZERO)) {
 			assert(
@@ -153,7 +163,7 @@ export class BigNum {
 	}
 
 	public eq(bn: BigNum | BN, ignorePrecision?: boolean): boolean {
-		const comparisonVal = bn instanceof BigNum ? bn : BigNum.from(bn);
+		const comparisonVal = this.bigNumFromParam(bn);
 
 		if (!ignorePrecision && !comparisonVal.val.eq(ZERO)) {
 			assert(
@@ -206,7 +216,8 @@ export class BigNum {
 			'Tried to print a BN with precision lower than zero'
 		);
 
-		const plainString = this.toString();
+		const isNeg = this.isNeg();
+		const plainString = this.abs().toString();
 		const precisionNum = this.precision.toNumber();
 
 		// make a string with at least the precisionNum number of zeroes
@@ -227,6 +238,9 @@ export class BigNum {
 		// add zero if leading delim
 		if (printString[0] === BigNum.delim) printString = `0${printString}`;
 
+		// Add minus if negative
+		if (isNeg) printString = `-${printString}`;
+
 		// remove trailing delim
 		if (printString[printString.length - 1] === BigNum.delim)
 			printString = printString.slice(0, printString.length - 1);
@@ -281,6 +295,8 @@ export class BigNum {
 			? this.toTradePrecision()
 			: this.print();
 
+		if (!printVal.includes(BigNum.delim)) return printVal;
+
 		return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
 	}
 
@@ -295,7 +311,11 @@ export class BigNum {
 	 * @param fixedPrecision
 	 * @returns
 	 */
-	public toFixed(fixedPrecision: number): string {
+	public toFixed(fixedPrecision: number, rounded = false): string {
+		if (rounded) {
+			return this.toRounded(fixedPrecision).toFixed(fixedPrecision);
+		}
+
 		const printString = this.print();
 
 		const [leftSide, rightSide] = printString.split(BigNum.delim);
@@ -310,16 +330,78 @@ export class BigNum {
 		return `${leftSide}${BigNum.delim}${filledRightSide}`;
 	}
 
+	private getZeroes(count: number) {
+		return new Array(Math.max(count, 0)).fill('0').join('');
+	}
+
+	public toRounded(roundingPrecision: number) {
+		const printString = this.toString();
+
+		let shouldRoundUp = false;
+
+		const roundingDigitChar = printString[roundingPrecision];
+
+		if (roundingDigitChar) {
+			const roundingDigitVal = Number(roundingDigitChar);
+			if (roundingDigitVal >= 5) shouldRoundUp = true;
+		}
+
+		if (shouldRoundUp) {
+			const valueWithRoundedPrecisionAdded = this.add(
+				BigNum.from(
+					new BN(10).pow(new BN(printString.length - roundingPrecision)),
+					this.precision
+				)
+			);
+
+			const roundedUpPrintString =
+				valueWithRoundedPrecisionAdded.toString().slice(0, roundingPrecision) +
+				this.getZeroes(printString.length - roundingPrecision);
+
+			return BigNum.from(roundedUpPrintString, this.precision);
+		} else {
+			const roundedDownPrintString =
+				printString.slice(0, roundingPrecision) +
+				this.getZeroes(printString.length - roundingPrecision);
+
+			return BigNum.from(roundedDownPrintString, this.precision);
+		}
+	}
+
 	/**
 	 * Pretty print to the specified number of significant figures
 	 * @param fixedPrecision
 	 * @returns
 	 */
-	public toPrecision(fixedPrecision: number, trailingZeroes = false): string {
+	public toPrecision(
+		fixedPrecision: number,
+		trailingZeroes = false,
+		rounded = false
+	): string {
+		if (rounded) {
+			return this.toRounded(fixedPrecision).toPrecision(
+				fixedPrecision,
+				trailingZeroes
+			);
+		}
+
 		const printString = this.print();
 
 		let precisionPrintString = printString.slice(0, fixedPrecision + 1);
 
+		const thisString = this.toString();
+
+		if (
+			!printString.includes(BigNum.delim) &&
+			thisString.length < fixedPrecision
+		) {
+			const precisionMismatch = fixedPrecision - thisString.length;
+			return BigNum.from(
+				thisString + this.getZeroes(precisionMismatch),
+				precisionMismatch
+			).toPrecision(fixedPrecision, trailingZeroes);
+		}
+
 		if (
 			!precisionPrintString.includes(BigNum.delim) ||
 			precisionPrintString[precisionPrintString.length - 1] === BigNum.delim
@@ -376,8 +458,8 @@ export class BigNum {
 		return precisionPrintString;
 	}
 
-	public toTradePrecision(): string {
-		return this.toPrecision(6, true);
+	public toTradePrecision(rounded = false): string {
+		return this.toPrecision(6, true, rounded);
 	}
 
 	/**
@@ -392,15 +474,39 @@ export class BigNum {
 	): string {
 		const prefix = `${this.lt(BigNum.zero()) ? `-` : ``}$`;
 
-		const val =
-			useTradePrecision || precisionOverride
-				? this.prettyPrint(useTradePrecision, precisionOverride)
-				: BigNum.fromPrint(this.toFixed(2), new BN(2)).prettyPrint();
+		const usingCustomPrecision =
+			true && (useTradePrecision || precisionOverride);
+
+		let val = usingCustomPrecision
+			? this.prettyPrint(useTradePrecision, precisionOverride)
+			: BigNum.fromPrint(this.toFixed(2), new BN(2)).prettyPrint();
+
+		// Append two trailing zeroes if not using custom precision
+		if (!usingCustomPrecision) {
+			const [_, rightSide] = val.split(BigNum.delim);
+
+			const trailingLength = rightSide?.length ?? 0;
+
+			if (trailingLength < 2) {
+				const numHasDecimals = this.print().includes(BigNum.delim);
+
+				// Handle case where pretty print won't include the decimal point
+				if (trailingLength === 0 && numHasDecimals) {
+					val = `${val}.00`;
+				} else {
+					val = `${val}${new Array(2 - trailingLength).fill('0').join('')}`;
+				}
+			}
+		}
 
 		return `${prefix}${val.replace('-', '')}`;
 	}
 
-	public toMillified(precision = 3): string {
+	public toMillified(precision = 3, rounded = false): string {
+		if (rounded) {
+			return this.toRounded(precision).toMillified(precision);
+		}
+
 		const stringVal = this.print();
 
 		const [leftSide] = stringVal.split(BigNum.delim);
@@ -409,6 +515,10 @@ export class BigNum {
 			return this.shift(new BN(precision)).toPrecision(precision, true);
 		}
 
+		if (leftSide.length <= precision) {
+			return this.toPrecision(precision);
+		}
+
 		if (leftSide.length <= 3) {
 			return this.shift(new BN(precision)).toPrecision(precision, true);
 		}
@@ -461,7 +571,21 @@ export class BigNum {
 	 * @returns
 	 */
 	public toNum() {
-		return parseFloat(this.print());
+		let printedValue = this.print();
+
+		// Must convert any non-US delimiters and spacers to US format before using parseFloat
+		if (BigNum.delim !== '.' || BigNum.spacer !== ',') {
+			printedValue = printedValue
+				.split('')
+				.map((char) => {
+					if (char === BigNum.delim) return '.';
+					if (char === BigNum.spacer) return ',';
+					return char;
+				})
+				.join('');
+		}
+
+		return parseFloat(printedValue);
 	}
 
 	static fromJSON(json: { val: string; precision: string }) {
@@ -494,12 +618,16 @@ export class BigNum {
 	static fromPrint(val: string, precisionShift?: BN): BigNum {
 		// Handle empty number edge cases
 		if (!val) return BigNum.from(ZERO, precisionShift);
-		if (!val.replace(BigNum.delim, ''))
+		if (!val.replace(BigNum.delim, '')) {
 			return BigNum.from(ZERO, precisionShift);
+		}
 
-		const [leftSide, rightSide] = val.split(BigNum.delim);
+		const sides = val.split(BigNum.delim);
+		const rightSide = sides[1];
+		const leftSide = sides[0].replace(/\D/g, '');
+		const bnInput = `${leftSide ?? ''}${rightSide ?? ''}`;
 
-		const rawBn = new BN(`${leftSide ?? ''}${rightSide ?? ''}`);
+		const rawBn = new BN(bnInput);
 
 		const rightSideLength = rightSide?.length ?? 0;