@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/src/dlob/DLOBNode.ts

@@ -0,0 +1,163 @@
+import {
+	isOneOfVariant,
+	AMM_RESERVE_PRECISION,
+	BN,
+	convertToNumber,
+	getLimitPrice,
+	isVariant,
+	SpotMarketAccount,
+	PerpMarketAccount,
+	MARK_PRICE_PRECISION,
+	OraclePriceData,
+	Order,
+	ZERO,
+} from '..';
+import { PublicKey } from '@solana/web3.js';
+import { getOrderSignature } from './NodeList';
+
+export interface DLOBNode {
+	getPrice(oraclePriceData: OraclePriceData, slot: number): BN;
+	isVammNode(): boolean;
+	order: Order | undefined;
+	haveFilled: boolean;
+	userAccount: PublicKey | undefined;
+	market: SpotMarketAccount | PerpMarketAccount;
+}
+
+export abstract class OrderNode implements DLOBNode {
+	order: Order;
+	market: SpotMarketAccount | PerpMarketAccount;
+	userAccount: PublicKey;
+	sortValue: BN;
+	haveFilled = false;
+	haveTrigger = false;
+
+	constructor(
+		order: Order,
+		market: SpotMarketAccount | PerpMarketAccount,
+		userAccount: PublicKey
+	) {
+		this.order = order;
+		this.market = market;
+		this.userAccount = userAccount;
+		this.sortValue = this.getSortValue(order);
+	}
+
+	abstract getSortValue(order: Order): BN;
+
+	public getLabel(): string {
+		let msg = `Order ${getOrderSignature(
+			this.order.orderId,
+			this.userAccount
+		)}`;
+		msg += ` ${isVariant(this.order.direction, 'long') ? 'LONG' : 'SHORT'} `;
+		msg += `${convertToNumber(
+			this.order.baseAssetAmount,
+			AMM_RESERVE_PRECISION
+		).toFixed(3)}`;
+		if (this.order.price.gt(ZERO)) {
+			msg += ` @ ${convertToNumber(
+				this.order.price,
+				MARK_PRICE_PRECISION
+			).toFixed(3)}`;
+		}
+		if (this.order.triggerPrice.gt(ZERO)) {
+			msg += ` ${
+				isVariant(this.order.triggerCondition, 'below') ? 'BELOW' : 'ABOVE'
+			}`;
+			msg += ` ${convertToNumber(
+				this.order.triggerPrice,
+				MARK_PRICE_PRECISION
+			).toFixed(3)}`;
+		}
+		return msg;
+	}
+
+	getPrice(oraclePriceData: OraclePriceData, slot: number): BN {
+		if (isOneOfVariant(this.order.marketType, ['spot'])) {
+			return getLimitPrice(this.order, oraclePriceData, slot);
+		} else if (isOneOfVariant(this.order.marketType, ['perp'])) {
+			return getLimitPrice(
+				this.order,
+				oraclePriceData,
+				slot,
+				this.market as PerpMarketAccount
+			);
+		} else {
+			console.error(`Unknown market type: ${this.order.marketType}`);
+		}
+	}
+
+	isVammNode(): boolean {
+		return false;
+	}
+}
+
+export class LimitOrderNode extends OrderNode {
+	next?: LimitOrderNode;
+	previous?: LimitOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.price;
+	}
+}
+
+export class FloatingLimitOrderNode extends OrderNode {
+	next?: FloatingLimitOrderNode;
+	previous?: FloatingLimitOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.oraclePriceOffset;
+	}
+}
+
+export class MarketOrderNode extends OrderNode {
+	next?: MarketOrderNode;
+	previous?: MarketOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.slot;
+	}
+}
+
+export class TriggerOrderNode extends OrderNode {
+	next?: TriggerOrderNode;
+	previous?: TriggerOrderNode;
+
+	getSortValue(order: Order): BN {
+		return order.triggerPrice;
+	}
+}
+
+export type DLOBNodeMap = {
+	limit: LimitOrderNode;
+	floatingLimit: FloatingLimitOrderNode;
+	market: MarketOrderNode;
+	trigger: TriggerOrderNode;
+};
+
+export type DLOBNodeType =
+	| 'limit'
+	| 'floatingLimit'
+	| 'market'
+	| ('trigger' & keyof DLOBNodeMap);
+
+export function createNode<T extends DLOBNodeType>(
+	nodeType: T,
+	order: Order,
+	market: SpotMarketAccount | PerpMarketAccount,
+	userAccount: PublicKey
+): DLOBNodeMap[T] {
+	switch (nodeType) {
+		case 'floatingLimit':
+			return new FloatingLimitOrderNode(order, market, userAccount);
+		case 'limit':
+			return new LimitOrderNode(order, market, userAccount);
+		case 'market':
+			return new MarketOrderNode(order, market, userAccount);
+		case 'trigger':
+			return new TriggerOrderNode(order, market, userAccount);
+		default:
+			throw Error(`Unknown DLOBNode type ${nodeType}`);
+	}
+}

package/src/dlob/NodeList.ts

@@ -0,0 +1,185 @@
+import {
+	BN,
+	isVariant,
+	MarketTypeStr,
+	Order,
+	PerpMarketAccount,
+	SpotMarketAccount,
+} from '..';
+import { PublicKey } from '@solana/web3.js';
+import { createNode, DLOBNode, DLOBNodeMap } from './DLOBNode';
+
+export type SortDirection = 'asc' | 'desc';
+
+export function getOrderSignature(orderId: BN, userAccount: PublicKey): string {
+	return `${userAccount.toString()}-${orderId.toString()}`;
+}
+
+export interface DLOBNodeGenerator {
+	getGenerator(): Generator<DLOBNode>;
+}
+
+export class NodeList<NodeType extends keyof DLOBNodeMap>
+	implements DLOBNodeGenerator
+{
+	head?: DLOBNodeMap[NodeType];
+	length = 0;
+	nodeMap = new Map<string, DLOBNodeMap[NodeType]>();
+
+	constructor(
+		private nodeType: NodeType,
+		private sortDirection: SortDirection
+	) {}
+
+	public insert(
+		order: Order,
+		marketType: MarketTypeStr,
+		market: PerpMarketAccount | SpotMarketAccount,
+		userAccount: PublicKey
+	): void {
+		if (isVariant(order.status, 'init')) {
+			return;
+		}
+
+		if (marketType === 'spot') {
+			market = market as SpotMarketAccount;
+		} else if (marketType === 'perp') {
+			market = market as PerpMarketAccount;
+		}
+
+		const newNode = createNode(this.nodeType, order, market, userAccount);
+
+		const orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			return;
+		}
+		this.nodeMap.set(orderId, newNode);
+
+		this.length += 1;
+
+		if (this.head === undefined) {
+			this.head = newNode;
+			return;
+		}
+
+		if (this.prependNode(this.head, newNode)) {
+			this.head.previous = newNode;
+			newNode.next = this.head;
+			this.head = newNode;
+			return;
+		}
+
+		let currentNode = this.head;
+		while (
+			currentNode.next !== undefined &&
+			!this.prependNode(currentNode.next, newNode)
+		) {
+			currentNode = currentNode.next;
+		}
+
+		newNode.next = currentNode.next;
+		if (currentNode.next !== undefined) {
+			newNode.next.previous = newNode;
+		}
+		currentNode.next = newNode;
+		newNode.previous = currentNode;
+	}
+
+	prependNode(
+		currentNode: DLOBNodeMap[NodeType],
+		newNode: DLOBNodeMap[NodeType]
+	): boolean {
+		const currentOrder = currentNode.order;
+		const newOrder = newNode.order;
+
+		const currentOrderSortPrice = currentNode.sortValue;
+		const newOrderSortPrice = newNode.sortValue;
+
+		if (newOrderSortPrice.eq(currentOrderSortPrice)) {
+			return newOrder.ts.lt(currentOrder.ts);
+		}
+
+		if (this.sortDirection === 'asc') {
+			return newOrderSortPrice.lt(currentOrderSortPrice);
+		} else {
+			return newOrderSortPrice.gt(currentOrderSortPrice);
+		}
+	}
+
+	public update(order: Order, userAccount: PublicKey): void {
+		const orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			const node = this.nodeMap.get(orderId);
+			Object.assign(node.order, order);
+			node.haveFilled = false;
+		}
+	}
+
+	public remove(order: Order, userAccount: PublicKey): void {
+		const orderId = getOrderSignature(order.orderId, userAccount);
+		if (this.nodeMap.has(orderId)) {
+			const node = this.nodeMap.get(orderId);
+			if (node.next) {
+				node.next.previous = node.previous;
+			}
+			if (node.previous) {
+				node.previous.next = node.next;
+			}
+
+			if (this.head && node.order.orderId.eq(this.head.order.orderId)) {
+				this.head = node.next;
+			}
+
+			node.previous = undefined;
+			node.next = undefined;
+
+			this.nodeMap.delete(orderId);
+
+			this.length--;
+		}
+	}
+
+	*getGenerator(): Generator<DLOBNode> {
+		let node = this.head;
+		while (node !== undefined) {
+			yield node;
+			node = node.next;
+		}
+	}
+
+	public has(order: Order, userAccount: PublicKey): boolean {
+		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
+	}
+
+	public print(): void {
+		let currentNode = this.head;
+		while (currentNode !== undefined) {
+			console.log(currentNode.getLabel());
+			currentNode = currentNode.next;
+		}
+	}
+
+	public printTop(): void {
+		if (this.head) {
+			console.log(this.sortDirection.toUpperCase(), this.head.getLabel());
+		} else {
+			console.log('---');
+		}
+	}
+}
+
+export function* getVammNodeGenerator(
+	price: BN | undefined
+): Generator<DLOBNode> {
+	if (!price) {
+		return;
+	}
+	yield {
+		getPrice: () => price,
+		isVammNode: () => true,
+		order: undefined,
+		market: undefined,
+		userAccount: undefined,
+		haveFilled: false,
+	};
+}

package/src/events/types.ts

@@ -9,6 +9,7 @@ import {
 	OrderRecord,
 	SettlePnlRecord,
 	LPRecord,
+	InsuranceFundRecord,
 } from '../index';
 
 export type EventSubscriptionOptions = {
@@ -35,6 +36,7 @@ export const DefaultEventSubscriptionOptions: EventSubscriptionOptions = {
 		'NewUserRecord',
 		'SettlePnlRecord',
 		'LPRecord',
+		'InsuranceFundRecord',
 	],
 	maxEventsPerType: 4096,
 	orderBy: 'blockchain',
@@ -71,6 +73,7 @@ export type EventMap = {
 	SettlePnlRecord: Event<SettlePnlRecord>;
 	NewUserRecord: Event<NewUserRecord>;
 	LPRecord: Event<LPRecord>;
+	InsuranceFundRecord: Event<InsuranceFundRecord>;
 };
 
 export type EventType = keyof EventMap;

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.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.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);
+	});
 main();

package/src/examples/makeTradeExample.ts

@@ -11,11 +11,11 @@ import {
 	convertToNumber,
 	calculateTradeSlippage,
 	BulkAccountLoader,
-	Markets,
+	PerpMarkets,
 	MARK_PRICE_PRECISION,
 	QUOTE_PRECISION,
 } from '..';
-import { Banks } from '../constants/banks';
+import { SpotMarkets } from '../constants/spotMarkets';
 
 export const getTokenAddress = (
 	mintAddress: string,
@@ -76,8 +76,10 @@ const main = async () => {
 		connection,
 		wallet: provider.wallet,
 		programID: clearingHousePublicKey,
-		marketIndexes: Markets[cluster].map((market) => market.marketIndex),
-		bankIndexes: Banks[cluster].map((bank) => bank.bankIndex),
+		perpMarketIndexes: PerpMarkets[cluster].map((market) => market.marketIndex),
+		spotMarketIndexes: SpotMarkets[cluster].map(
+			(spotMarket) => spotMarket.marketIndex
+		),
 		accountSubscription: {
 			type: 'polling',
 			accountLoader: bulkAccountLoader,
@@ -107,19 +109,19 @@ 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),
+		clearingHouse.getPerpMarketAccount(solMarketInfo.marketIndex),
 		undefined
 	);
 
@@ -131,7 +133,7 @@ const main = async () => {
 	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
 	);