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

package/src/{clearingHouseConfig.ts → driftClientConfig.ts}

@@ -1,26 +1,27 @@
 import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
 import { IWallet } from './types';
-import { BN } from '@project-serum/anchor';
 import { OracleInfo } from './oracles/types';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 import { DriftEnv } from './config';
 
-export type ClearingHouseConfig = {
+export type DriftClientConfig = {
 	connection: Connection;
 	wallet: IWallet;
 	programID: PublicKey;
-	accountSubscription?: ClearingHouseSubscriptionConfig;
+	accountSubscription?: DriftClientSubscriptionConfig;
 	opts?: ConfirmOptions;
 	txSenderConfig?: TxSenderConfig;
-	userIds?: number[];
-	activeUserId?: number;
-	marketIndexes?: BN[];
-	bankIndexes?: BN[];
+	subAccountIds?: number[];
+	activeSubAccountId?: number;
+	perpMarketIndexes?: number[];
+	spotMarketIndexes?: number[];
 	oracleInfos?: OracleInfo[];
 	env?: DriftEnv;
+	userStats?: boolean;
+	authority?: PublicKey; // explicitly pass an authority if signer is delegate
 };
 
-type ClearingHouseSubscriptionConfig =
+type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
 	  }

package/src/events/eventList.ts

@@ -53,7 +53,10 @@ export class EventList<Type extends EventType> {
 			newNode.next = currentNode.next;
 			if (currentNode.next !== undefined) {
 				newNode.next.prev = newNode;
+			} else {
+				this.tail = newNode;
 			}
+
 			currentNode.next = newNode;
 			newNode.prev = currentNode;
 		}

package/src/events/eventSubscriber.ts

@@ -25,6 +25,9 @@ export class EventSubscriber {
 	private awaitTxResolver = new Map<string, () => void>();
 	private logProvider: LogProvider;
 	public eventEmitter: StrictEventEmitter<EventEmitter, EventSubscriberEvents>;
+	private lastSeenSlot: number;
+	private lastSeenBlockTime: number | undefined;
+	public lastSeenTxSig: string;
 
 	public constructor(
 		private connection: Connection,
@@ -62,25 +65,29 @@ export class EventSubscriber {
 		}
 	}
 
-	public subscribe(): boolean {
-		if (this.logProvider.isSubscribed()) {
-			return true;
-		}
+	public async subscribe(): Promise<boolean> {
+		try {
+			if (this.logProvider.isSubscribed()) {
+				return true;
+			}
 
-		this.fetchPreviousTx().catch((e) => {
+			this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
+				this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
+			}, true);
+
+			return true;
+		} catch (e) {
 			console.error('Error fetching previous txs in event subscriber');
 			console.error(e);
-		});
-
-		return this.logProvider.subscribe((txSig, slot, logs) => {
-			this.handleTxLogs(txSig, slot, logs);
-		});
+			return false;
+		}
 	}
 
 	private handleTxLogs(
 		txSig: TransactionSignature,
 		slot: number,
-		logs: string[]
+		logs: string[],
+		mostRecentBlockTime: number | undefined
 	): void {
 		if (this.txEventCache.has(txSig)) {
 			return;
@@ -89,6 +96,10 @@ export class EventSubscriber {
 		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
 		for (const wrappedEvent of wrappedEvents) {
 			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
+		}
+
+		// dont emit event till we've added all the events to the eventListMap
+		for (const wrappedEvent of wrappedEvents) {
 			this.eventEmitter.emit('newEvent', wrappedEvent);
 		}
 
@@ -98,11 +109,22 @@ export class EventSubscriber {
 			this.awaitTxResolver.delete(txSig);
 		}
 
+		if (slot > this.lastSeenSlot) {
+			this.lastSeenTxSig = txSig;
+		}
+
+		if (
+			this.lastSeenBlockTime === undefined ||
+			mostRecentBlockTime > this.lastSeenBlockTime
+		) {
+			this.lastSeenBlockTime = mostRecentBlockTime;
+		}
+
 		this.txEventCache.add(txSig, wrappedEvents);
 	}
 
-	private async fetchPreviousTx(): Promise<void> {
-		if (!this.options.untilTx) {
+	public async fetchPreviousTx(fetchMax?: boolean): Promise<void> {
+		if (!this.options.untilTx && !fetchMax) {
 			return;
 		}
 
@@ -126,7 +148,7 @@ export class EventSubscriber {
 			beforeTx = response.earliestTx;
 
 			for (const { txSig, slot, logs } of response.transactionLogs) {
-				this.handleTxLogs(txSig, slot, logs);
+				this.handleTxLogs(txSig, slot, logs, response.mostRecentBlockTime);
 			}
 		}
 	}

package/src/events/fetchLogs.ts

@@ -1,35 +1,51 @@
+import { Program } from '@project-serum/anchor';
 import {
 	Connection,
 	Finality,
 	PublicKey,
+	TransactionResponse,
 	TransactionSignature,
 } from '@solana/web3.js';
+import { WrappedEvents } from './types';
 
 type Log = { txSig: TransactionSignature; slot: number; logs: string[] };
 type FetchLogsResponse = {
 	earliestTx: string;
 	mostRecentTx: string;
+	earliestSlot: number;
+	mostRecentSlot: number;
 	transactionLogs: Log[];
+	mostRecentBlockTime: number | undefined;
 };
 
+function mapTransactionResponseToLog(transaction: TransactionResponse): Log {
+	return {
+		txSig: transaction.transaction.signatures[0],
+		slot: transaction.slot,
+		logs: transaction.meta.logMessages,
+	};
+}
+
 export async function fetchLogs(
 	connection: Connection,
 	programId: PublicKey,
 	finality: Finality,
 	beforeTx?: TransactionSignature,
-	untilTx?: TransactionSignature
-): Promise<FetchLogsResponse | undefined> {
+	untilTx?: TransactionSignature,
+	limit?: number
+): Promise<FetchLogsResponse> {
 	const signatures = await connection.getSignaturesForAddress(
 		programId,
 		{
 			before: beforeTx,
 			until: untilTx,
+			limit,
 		},
 		finality
 	);
 
 	const sortedSignatures = signatures.sort((a, b) =>
-		a.slot < b.slot ? -1 : 1
+		a.slot === b.slot ? 0 : a.slot < b.slot ? -1 : 1
 	);
 
 	const filteredSignatures = sortedSignatures.filter(
@@ -50,25 +66,26 @@ export async function fetchLogs(
 					finality
 				);
 
-				return transactions.map((transaction) => {
-					return {
-						txSig: transaction.transaction.signatures[0],
-						slot: transaction.slot,
-						logs: transaction.meta.logMessages,
-					};
-				});
+				return transactions.reduce((logs, transaction) => {
+					if (transaction) {
+						logs.push(mapTransactionResponseToLog(transaction));
+					}
+					return logs;
+				}, new Array<Log>());
 			})
 		)
 	).flat();
 
-	const earliestTx = filteredSignatures[0].signature;
-	const mostRecentTx =
-		filteredSignatures[filteredSignatures.length - 1].signature;
+	const earliest = filteredSignatures[0];
+	const mostRecent = filteredSignatures[filteredSignatures.length - 1];
 
 	return {
 		transactionLogs: transactionLogs,
-		earliestTx: earliestTx,
-		mostRecentTx: mostRecentTx,
+		earliestTx: earliest.signature,
+		mostRecentTx: mostRecent.signature,
+		earliestSlot: earliest.slot,
+		mostRecentSlot: mostRecent.slot,
+		mostRecentBlockTime: mostRecent.blockTime,
 	};
 }
 
@@ -78,3 +95,31 @@ function chunk<T>(array: readonly T[], size: number): T[][] {
 		.map((_, index) => index * size)
 		.map((begin) => array.slice(begin, begin + size));
 }
+
+export class LogParser {
+	private program: Program;
+
+	constructor(program: Program) {
+		this.program = program;
+	}
+
+	public parseEventsFromTransaction(
+		transaction: TransactionResponse
+	): WrappedEvents {
+		const transactionLogObject = mapTransactionResponseToLog(transaction);
+
+		return this.parseEventsFromLogs(transactionLogObject);
+	}
+
+	public parseEventsFromLogs(event: Log): WrappedEvents {
+		const records: WrappedEvents = [];
+		// @ts-ignore
+		this.program._events._eventParser.parseLogs(event.logs, (eventLog) => {
+			eventLog.data.txSig = event.txSig;
+			eventLog.data.slot = event.slot;
+			eventLog.data.eventType = eventLog.name;
+			records.push(eventLog.data);
+		});
+		return records;
+	}
+}

package/src/events/pollingLogProvider.ts

@@ -13,6 +13,7 @@ export class PollingLogProvider implements LogProvider {
 	private intervalId: NodeJS.Timer;
 	private mostRecentSeenTx?: TransactionSignature;
 	private mutex: number;
+	private firstFetch = true;
 
 	public constructor(
 		private connection: Connection,
@@ -23,7 +24,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): boolean {
 		if (this.intervalId) {
 			return true;
 		}
@@ -40,9 +44,13 @@ export class PollingLogProvider implements LogProvider {
 					this.programId,
 					this.finality,
 					undefined,
-					this.mostRecentSeenTx
+					this.mostRecentSeenTx,
+					// If skipping history, only fetch one log back, not the maximum amount available
+					skipHistory && this.firstFetch ? 1 : undefined
 				);
 
+				this.firstFetch = false;
+
 				if (response === undefined) {
 					return;
 				}
@@ -50,7 +58,7 @@ export class PollingLogProvider implements LogProvider {
 				const { mostRecentTx, transactionLogs } = response;
 
 				for (const { txSig, slot, logs } of transactionLogs) {
-					callback(txSig, slot, logs);
+					callback(txSig, slot, logs, response.mostRecentBlockTime);
 				}
 
 				this.mostRecentSeenTx = mostRecentTx;

package/src/events/sort.ts

@@ -6,8 +6,8 @@ import {
 	SortFn,
 	Event,
 } from './types';
-import { OrderRecord } from '../types';
-import { PublicKey, ZERO } from '../index';
+import { OrderActionRecord } from '../types';
+import { ZERO } from '../index';
 
 function clientSortAscFn(): 'less than' {
 	return 'less than';
@@ -24,21 +24,17 @@ function defaultBlockchainSortFn(
 	return currentEvent.slot <= newEvent.slot ? 'less than' : 'greater than';
 }
 
-function orderRecordSortFn(
-	currentEvent: Event<OrderRecord>,
-	newEvent: Event<OrderRecord>
+function orderActionRecordSortFn(
+	currentEvent: Event<OrderActionRecord>,
+	newEvent: Event<OrderActionRecord>
 ): 'less than' | 'greater than' {
-	const currentEventMarketIndex = !currentEvent.maker.equals(PublicKey.default)
-		? currentEvent.makerOrder.marketIndex
-		: currentEvent.takerOrder.marketIndex;
-	const newEventMarketIndex = !newEvent.maker.equals(PublicKey.default)
-		? newEvent.makerOrder.marketIndex
-		: newEvent.takerOrder.marketIndex;
-	if (!currentEventMarketIndex.eq(newEventMarketIndex)) {
+	const currentEventMarketIndex = currentEvent.marketIndex;
+	const newEventMarketIndex = newEvent.marketIndex;
+	if (currentEventMarketIndex !== newEventMarketIndex) {
 		return currentEvent.ts.lte(newEvent.ts) ? 'less than' : 'greater than';
 	}
 
-	if (currentEvent.fillRecordId.gt(ZERO) && newEvent.fillRecordId.gt(ZERO)) {
+	if (currentEvent.fillRecordId?.gt(ZERO) && newEvent.fillRecordId?.gt(ZERO)) {
 		return currentEvent.fillRecordId.lte(newEvent.fillRecordId)
 			? 'less than'
 			: 'greater than';
@@ -57,8 +53,8 @@ export function getSortFn(
 	}
 
 	switch (eventType) {
-		case 'OrderRecord':
-			return orderRecordSortFn;
+		case 'OrderActionRecord':
+			return orderActionRecordSortFn;
 		default:
 			return defaultBlockchainSortFn;
 	}

package/src/events/types.ts

@@ -4,7 +4,15 @@ import {
 	FundingPaymentRecord,
 	FundingRateRecord,
 	LiquidationRecord,
+	NewUserRecord,
+	OrderActionRecord,
 	OrderRecord,
+	SettlePnlRecord,
+	LPRecord,
+	InsuranceFundRecord,
+	SpotInterestRecord,
+	InsuranceFundStakeRecord,
+	CurveRecord,
 } from '../index';
 
 export type EventSubscriptionOptions = {
@@ -26,7 +34,15 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'FundingPaymentRecord',
 		'LiquidationRecord',
 		'OrderRecord',
+		'OrderActionRecord',
 		'FundingRateRecord',
+		'NewUserRecord',
+		'SettlePnlRecord',
+		'LPRecord',
+		'InsuranceFundRecord',
+		'SpotInterestRecord',
+		'InsuranceFundStakeRecord',
+		'CurveRecord',
 	],
 	maxEventsPerType: 4096,
 	orderBy: 'blockchain',
@@ -59,6 +75,14 @@ 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>;
+	InsuranceFundStakeRecord: Event<InsuranceFundStakeRecord>;
+	CurveRecord: Event<CurveRecord>;
 };
 
 export type EventType = keyof EventMap;
@@ -75,12 +99,13 @@ export type SortFn = (
 export type logProviderCallback = (
 	txSig: TransactionSignature,
 	slot: number,
-	logs: string[]
+	logs: string[],
+	mostRecentBlockTime: number | undefined
 ) => void;
 
 export interface LogProvider {
 	isSubscribed(): boolean;
-	subscribe(callback: logProviderCallback): boolean;
+	subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
 	unsubscribe(): Promise<boolean>;
 }
 

package/src/events/webSocketLogProvider.ts

@@ -17,7 +17,7 @@ export class WebSocketLogProvider implements LogProvider {
 		this.subscriptionId = this.connection.onLogs(
 			this.programId,
 			(logs, ctx) => {
-				callback(logs.signature, ctx.slot, logs.logs);
+				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment
 		);

package/src/examples/makeTradeExample.js

@@ -1,80 +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 });
+'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/banks");
+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));
+	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.Banks['devnet'][0].bankIndex);
-    }
-    yield user.subscribe();
-    // Get current price
-    const solMarketInfo = sdkConfig.MARKETS.find((market) => market.baseAssetSymbol === 'SOL');
-    const currentMarketPrice = __2.calculateMarkPrice(clearingHouse.getMarketAccount(solMarketInfo.marketIndex), undefined);
-    const formattedPrice = __2.convertToNumber(currentMarketPrice, __2.MARK_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.MARK_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);
-});
+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.DRIFT_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();