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

package/src/events/types.ts

@@ -4,7 +4,13 @@ import {
 	FundingPaymentRecord,
 	FundingRateRecord,
 	LiquidationRecord,
+	NewUserRecord,
+	OrderActionRecord,
 	OrderRecord,
+	SettlePnlRecord,
+	LPRecord,
+	InsuranceFundRecord,
+	SpotInterestRecord,
 } from '../index';
 
 export type EventSubscriptionOptions = {
@@ -26,7 +32,13 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'FundingPaymentRecord',
 		'LiquidationRecord',
 		'OrderRecord',
+		'OrderActionRecord',
 		'FundingRateRecord',
+		'NewUserRecord',
+		'SettlePnlRecord',
+		'LPRecord',
+		'InsuranceFundRecord',
+		'SpotInterestRecord',
 	],
 	maxEventsPerType: 4096,
 	orderBy: 'blockchain',
@@ -59,6 +71,12 @@ export type EventMap = {
 	LiquidationRecord: Event<LiquidationRecord>;
 	FundingRateRecord: Event<FundingRateRecord>;
 	OrderRecord: Event<OrderRecord>;
+	OrderActionRecord: Event<OrderActionRecord>;
+	SettlePnlRecord: Event<SettlePnlRecord>;
+	NewUserRecord: Event<NewUserRecord>;
+	LPRecord: Event<LPRecord>;
+	InsuranceFundRecord: Event<InsuranceFundRecord>;
+	SpotInterestRecord: Event<SpotInterestRecord>;
 };
 
 export type EventType = keyof EventMap;
@@ -80,7 +98,7 @@ export type logProviderCallback = (
 
 export interface LogProvider {
 	isSubscribed(): boolean;
-	subscribe(callback: logProviderCallback): boolean;
+	subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
 	unsubscribe(): Promise<boolean>;
 }
 

package/src/examples/makeTradeExample.js

@@ -0,0 +1,157 @@
+'use strict';
+var __awaiter =
+	(this && this.__awaiter) ||
+	function (thisArg, _arguments, P, generator) {
+		function adopt(value) {
+			return value instanceof P
+				? value
+				: new P(function (resolve) {
+						resolve(value);
+				  });
+		}
+		return new (P || (P = Promise))(function (resolve, reject) {
+			function fulfilled(value) {
+				try {
+					step(generator.next(value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function rejected(value) {
+				try {
+					step(generator['throw'](value));
+				} catch (e) {
+					reject(e);
+				}
+			}
+			function step(result) {
+				result.done
+					? resolve(result.value)
+					: adopt(result.value).then(fulfilled, rejected);
+			}
+			step((generator = generator.apply(thisArg, _arguments || [])).next());
+		});
+	};
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.getTokenAddress = void 0;
+const anchor_1 = require('@project-serum/anchor');
+const __1 = require('..');
+const spl_token_1 = require('@solana/spl-token');
+const web3_js_1 = require('@solana/web3.js');
+const __2 = require('..');
+const banks_1 = require('../constants/spotMarkets');
+const getTokenAddress = (mintAddress, userPubKey) => {
+	return spl_token_1.Token.getAssociatedTokenAddress(
+		new web3_js_1.PublicKey(`ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL`),
+		spl_token_1.TOKEN_PROGRAM_ID,
+		new web3_js_1.PublicKey(mintAddress),
+		new web3_js_1.PublicKey(userPubKey)
+	);
+};
+exports.getTokenAddress = getTokenAddress;
+const main = () =>
+	__awaiter(void 0, void 0, void 0, function* () {
+		// Initialize Drift SDK
+		const sdkConfig = __2.initialize({ env: 'devnet' });
+		// Set up the Wallet and Provider
+		const privateKey = process.env.BOT_PRIVATE_KEY; // stored as an array string
+		const keypair = web3_js_1.Keypair.fromSecretKey(
+			Uint8Array.from(JSON.parse(privateKey))
+		);
+		const wallet = new __1.Wallet(keypair);
+		// Set up the Connection
+		const rpcAddress = process.env.RPC_ADDRESS; // can use: https://api.devnet.solana.com for devnet; https://api.mainnet-beta.solana.com for mainnet;
+		const connection = new web3_js_1.Connection(rpcAddress);
+		// Set up the Provider
+		const provider = new anchor_1.AnchorProvider(
+			connection,
+			wallet,
+			anchor_1.AnchorProvider.defaultOptions()
+		);
+		// Check SOL Balance
+		const lamportsBalance = yield connection.getBalance(wallet.publicKey);
+		console.log('SOL balance:', lamportsBalance / Math.pow(10, 9));
+		// Misc. other things to set up
+		const usdcTokenAddress = yield exports.getTokenAddress(
+			sdkConfig.USDC_MINT_ADDRESS,
+			wallet.publicKey.toString()
+		);
+		// Set up the Drift Clearing House
+		const clearingHousePublicKey = new web3_js_1.PublicKey(
+			sdkConfig.CLEARING_HOUSE_PROGRAM_ID
+		);
+		const clearingHouse = new __2.ClearingHouse({
+			connection,
+			wallet: provider.wallet,
+			programID: clearingHousePublicKey,
+		});
+		yield clearingHouse.subscribe();
+		// Set up Clearing House user client
+		const user = new __2.ClearingHouseUser({
+			clearingHouse,
+			userAccountPublicKey: yield clearingHouse.getUserAccountPublicKey(),
+		});
+		//// Check if clearing house account exists for the current wallet
+		const userAccountExists = yield user.exists();
+		if (!userAccountExists) {
+			//// Create a Clearing House account by Depositing some USDC ($10,000 in this case)
+			const depositAmount = new anchor_1.BN(10000).mul(__2.QUOTE_PRECISION);
+			yield clearingHouse.initializeUserAccountAndDepositCollateral(
+				depositAmount,
+				yield exports.getTokenAddress(
+					usdcTokenAddress.toString(),
+					wallet.publicKey.toString()
+				),
+				banks_1.SpotMarkets['devnet'][0].marketIndex
+			);
+		}
+		yield user.subscribe();
+		// Get current price
+		const solMarketInfo = sdkConfig.PERP_MARKETS.find(
+			(market) => market.baseAssetSymbol === 'SOL'
+		);
+		const currentMarketPrice = __2.calculateMarkPrice(
+			clearingHouse.getMarketAccount(solMarketInfo.marketIndex),
+			undefined
+		);
+		const formattedPrice = __2.convertToNumber(
+			currentMarketPrice,
+			__2.PRICE_PRECISION
+		);
+		console.log(`Current Market Price is $${formattedPrice}`);
+		// Estimate the slippage for a $5000 LONG trade
+		const solMarketAccount = clearingHouse.getMarketAccount(
+			solMarketInfo.marketIndex
+		);
+		const longAmount = new anchor_1.BN(5000).mul(__2.QUOTE_PRECISION);
+		const slippage = __2.convertToNumber(
+			__2.calculateTradeSlippage(
+				__2.PositionDirection.LONG,
+				longAmount,
+				solMarketAccount,
+				'quote',
+				undefined
+			)[0],
+			__2.PRICE_PRECISION
+		);
+		console.log(
+			`Slippage for a $5000 LONG on the SOL market would be $${slippage}`
+		);
+		// Make a $5000 LONG trade
+		yield clearingHouse.openPosition(
+			__2.PositionDirection.LONG,
+			longAmount,
+			solMarketInfo.marketIndex
+		);
+		console.log(`LONGED $5000 SOL`);
+		// Reduce the position by $2000
+		const reduceAmount = new anchor_1.BN(2000).mul(__2.QUOTE_PRECISION);
+		yield clearingHouse.openPosition(
+			__2.PositionDirection.SHORT,
+			reduceAmount,
+			solMarketInfo.marketIndex
+		);
+		// Close the rest of the position
+		yield clearingHouse.closePosition(solMarketInfo.marketIndex);
+	});
+main();

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,
+	calculateReservePrice,
 	ClearingHouse,
 	ClearingHouseUser,
 	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
@@ -63,10 +67,23 @@ const main = async () => {
 	const clearingHousePublicKey = new PublicKey(
 		sdkConfig.CLEARING_HOUSE_PROGRAM_ID
 	);
+	const bulkAccountLoader = new BulkAccountLoader(
+		connection,
+		'confirmed',
+		1000
+	);
 	const clearingHouse = new ClearingHouse({
 		connection,
 		wallet: provider.wallet,
 		programID: clearingHousePublicKey,
+		perpMarketIndexes: PerpMarkets[cluster].map((market) => market.marketIndex),
+		spotMarketIndexes: SpotMarkets[cluster].map(
+			(spotMarket) => spotMarket.marketIndex
+		),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
 	});
 	await clearingHouse.subscribe();
 
@@ -74,6 +91,10 @@ const main = async () => {
 	const user = new ClearingHouseUser({
 		clearingHouse,
 		userAccountPublicKey: await clearingHouse.getUserAccountPublicKey(),
+		accountSubscription: {
+			type: 'polling',
+			accountLoader: bulkAccountLoader,
+		},
 	});
 
 	//// Check if clearing house account exists for the current wallet
@@ -88,31 +109,28 @@ const main = async () => {
 				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(
+		clearingHouse.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 = clearingHouse.getPerpMarketAccount(
 		solMarketInfo.marketIndex
 	);
 
@@ -125,7 +143,7 @@ const main = async () => {
 			'quote',
 			undefined
 		)[0],
-		MARK_PRICE_PRECISION
+		PRICE_PRECISION
 	);
 
 	console.log(

package/src/factory/bigNum.ts

@@ -17,6 +17,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 +34,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 +48,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 +57,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 +106,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 +119,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 +132,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 +145,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 +158,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 +211,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 +233,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 +290,8 @@ export class BigNum {
 			? this.toTradePrecision()
 			: this.print();
 
+		if (!printVal.includes(BigNum.delim)) return printVal;
+
 		return printVal.replace(/0+$/g, '').replace(/\.$/, '').replace(/,$/, '');
 	}
 
@@ -310,6 +321,10 @@ export class BigNum {
 		return `${leftSide}${BigNum.delim}${filledRightSide}`;
 	}
 
+	private getZeroes(count: number) {
+		return new Array(count).fill('0').join('');
+	}
+
 	/**
 	 * Pretty print to the specified number of significant figures
 	 * @param fixedPrecision
@@ -320,6 +335,19 @@ export class BigNum {
 
 		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
@@ -392,10 +420,30 @@ 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('-', '')}`;
 	}
@@ -409,6 +457,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);
 		}