@drift-labs/sdk 2.0.20 → 2.1.0

package/lib/dlob/DLOB.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="bn.js" />
 import { NodeList } from './NodeList';
-import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap } from '..';
+import { MarketType, BN, DriftClient, Order, SpotMarketAccount, PerpMarketAccount, OraclePriceData, SlotSubscriber, MarketTypeStr, StateAccount, UserMap, OrderRecord, OrderActionRecord } from '..';
 import { PublicKey } from '@solana/web3.js';
-import { DLOBNode, TriggerOrderNode } from '..';
+import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
 import { DLOBOrders } from './DLOBOrders';
 export declare type MarketNodeLists = {
     limit: {
@@ -43,10 +43,15 @@ export declare class DLOB {
      */
     initFromUserMap(userMap: UserMap): Promise<boolean>;
     initFromOrders(dlobOrders: DLOBOrders): boolean;
+    handleOrderRecord(record: OrderRecord): void;
+    handleOrderActionRecord(record: OrderActionRecord): void;
     insertOrder(order: Order, userAccount: PublicKey, onInsert?: OrderBookCallback): void;
     addOrderList(marketType: MarketTypeStr, marketIndex: number): void;
+    updateOrder(order: Order, userAccount: PublicKey, cumulativeBaseAssetAmountFilled: BN, onUpdate?: OrderBookCallback): void;
     trigger(order: Order, userAccount: PublicKey, onTrigger?: OrderBookCallback): void;
+    delete(order: Order, userAccount: PublicKey, onDelete?: OrderBookCallback): void;
     getListForOrder(order: Order): NodeList<any> | undefined;
+    getOrder(orderId: number, userAccount: PublicKey): Order | undefined;
     findNodesToFill(marketIndex: number, fallbackBid: BN | undefined, fallbackAsk: BN | undefined, slot: number, ts: number, marketType: MarketType, oraclePriceData: OraclePriceData, stateAccount: StateAccount, marketAccount: PerpMarketAccount | SpotMarketAccount): NodeToFill[];
     findLimitOrderNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid: BN | undefined): NodeToFill[];
     findMarketNodesToFill(marketIndex: number, slot: number, marketType: MarketType, oraclePriceData: OraclePriceData, isAmmPaused: boolean, fallbackAsk: BN | undefined, fallbackBid?: BN | undefined): NodeToFill[];
@@ -71,6 +76,6 @@ export declare class DLOB {
     findNodesToTrigger(marketIndex: number, slot: number, oraclePrice: BN, marketType: MarketType, stateAccount: StateAccount): NodeToTrigger[];
     printTopOfOrderLists(sdkConfig: any, driftClient: DriftClient, slotSubscriber: SlotSubscriber, marketIndex: number, marketType: MarketType): void;
     getDLOBOrders(): DLOBOrders;
-    getOrdersForMarket(marketIndex: number, marketType: MarketType, nodeLists: MarketNodeLists): DLOBOrders;
+    getNodeLists(): Generator<NodeList<DLOBNodeType>>;
 }
 export {};

package/lib/dlob/DLOB.js

@@ -63,6 +63,56 @@ class DLOB {
         this.initialized = true;
         return true;
     }
+    handleOrderRecord(record) {
+        this.insertOrder(record.order, record.user);
+    }
+    handleOrderActionRecord(record) {
+        if ((0, __1.isOneOfVariant)(record.action, ['place', 'expire'])) {
+            return;
+        }
+        if ((0, __1.isVariant)(record.action, 'trigger')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.trigger(takerOrder, record.taker);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.trigger(makerOrder, record.maker);
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(record.action, 'fill')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.updateOrder(takerOrder, record.taker, record.takerOrderCumulativeBaseAssetAmountFilled);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.updateOrder(makerOrder, record.maker, record.makerOrderCumulativeBaseAssetAmountFilled);
+                }
+            }
+        }
+        else if ((0, __1.isVariant)(record.action, 'cancel')) {
+            if (record.taker !== null) {
+                const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+                if (takerOrder) {
+                    this.delete(takerOrder, record.taker);
+                }
+            }
+            if (record.maker !== null) {
+                const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+                if (makerOrder) {
+                    this.delete(makerOrder, record.maker);
+                }
+            }
+        }
+    }
     insertOrder(order, userAccount, onInsert) {
         var _a;
         if ((0, __1.isVariant)(order.status, 'init')) {
@@ -102,11 +152,29 @@ class DLOB {
             },
         });
     }
+    updateOrder(order, userAccount, cumulativeBaseAssetAmountFilled, onUpdate) {
+        var _a;
+        if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
+            this.delete(order, userAccount);
+            return;
+        }
+        if (order.baseAssetAmountFilled.eq(cumulativeBaseAssetAmountFilled)) {
+            return;
+        }
+        order.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.update(order, userAccount);
+        if (onUpdate) {
+            onUpdate();
+        }
+    }
     trigger(order, userAccount, onTrigger) {
         var _a;
         if ((0, __1.isVariant)(order.status, 'init')) {
             return;
         }
+        if ((0, __1.isTriggered)(order)) {
+            return;
+        }
         const marketType = (0, __1.getVariant)(order.marketType);
         const triggerList = this.orderLists.get(marketType).get(order.marketIndex)
             .trigger[(0, __1.isVariant)(order.triggerCondition, 'above') ? 'above' : 'below'];
@@ -116,6 +184,16 @@ class DLOB {
             onTrigger();
         }
     }
+    delete(order, userAccount, onDelete) {
+        var _a;
+        if ((0, __1.isVariant)(order.status, 'init')) {
+            return;
+        }
+        (_a = this.getListForOrder(order)) === null || _a === void 0 ? void 0 : _a.remove(order, userAccount);
+        if (onDelete) {
+            onDelete();
+        }
+    }
     getListForOrder(order) {
         const isInactiveTriggerOrder = (0, __1.mustBeTriggered)(order) && !(0, __1.isTriggered)(order);
         let type;
@@ -144,6 +222,15 @@ class DLOB {
         }
         return this.orderLists.get(marketType).get(order.marketIndex)[type][subType];
     }
+    getOrder(orderId, userAccount) {
+        for (const nodeList of this.getNodeLists()) {
+            const node = nodeList.get(orderId, userAccount);
+            if (node) {
+                return node.order;
+            }
+        }
+        return undefined;
+    }
     findNodesToFill(marketIndex, fallbackBid, fallbackAsk, slot, ts, marketType, oraclePriceData, stateAccount, marketAccount) {
         if ((0, exchangeStatus_1.fillPaused)(stateAccount, marketAccount)) {
             return [];
@@ -644,66 +731,38 @@ class DLOB {
         }
     }
     getDLOBOrders() {
-        let dlobOrders = [];
-        for (const [marketIndex, nodeLists] of this.orderLists.get('perp')) {
-            dlobOrders = dlobOrders.concat(this.getOrdersForMarket(marketIndex, __1.MarketType.PERP, nodeLists));
-        }
-        for (const [marketIndex, nodeLists] of this.orderLists.get('spot')) {
-            dlobOrders = dlobOrders.concat(this.getOrdersForMarket(marketIndex, __1.MarketType.SPOT, nodeLists));
+        const dlobOrders = [];
+        for (const nodeList of this.getNodeLists()) {
+            for (const node of nodeList.getGenerator()) {
+                dlobOrders.push({
+                    user: node.userAccount,
+                    order: node.order,
+                });
+            }
         }
         return dlobOrders;
     }
-    getOrdersForMarket(marketIndex, marketType, nodeLists) {
-        const orders = [];
-        for (const node of nodeLists.limit.bid.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.limit.ask.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.market.bid.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.market.ask.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.floatingLimit.bid.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.floatingLimit.ask.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.trigger.below.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
-        }
-        for (const node of nodeLists.trigger.above.getGenerator()) {
-            orders.push({
-                user: node.userAccount,
-                order: node.order,
-            });
+    *getNodeLists() {
+        for (const [_, nodeLists] of this.orderLists.get('perp')) {
+            yield nodeLists.limit.bid;
+            yield nodeLists.limit.ask;
+            yield nodeLists.market.bid;
+            yield nodeLists.market.ask;
+            yield nodeLists.floatingLimit.bid;
+            yield nodeLists.floatingLimit.ask;
+            yield nodeLists.trigger.above;
+            yield nodeLists.trigger.below;
+        }
+        for (const [_, nodeLists] of this.orderLists.get('spot')) {
+            yield nodeLists.limit.bid;
+            yield nodeLists.limit.ask;
+            yield nodeLists.market.bid;
+            yield nodeLists.market.ask;
+            yield nodeLists.floatingLimit.bid;
+            yield nodeLists.floatingLimit.ask;
+            yield nodeLists.trigger.above;
+            yield nodeLists.trigger.below;
         }
-        return orders;
     }
 }
 exports.DLOB = DLOB;

package/lib/dlob/NodeList.d.ts

@@ -21,6 +21,7 @@ export declare class NodeList<NodeType extends keyof DLOBNodeMap> implements DLO
     remove(order: Order, userAccount: PublicKey): void;
     getGenerator(): Generator<DLOBNode>;
     has(order: Order, userAccount: PublicKey): boolean;
+    get(orderId: number, userAccount: PublicKey): DLOBNodeMap[NodeType] | undefined;
     print(): void;
     printTop(): void;
 }

package/lib/dlob/NodeList.js

@@ -104,6 +104,9 @@ class NodeList {
     has(order, userAccount) {
         return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
     }
+    get(orderId, userAccount) {
+        return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+    }
     print() {
         let currentNode = this.head;
         while (currentNode !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.0.20",
+	"version": "2.1.0",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/assert/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+function assert(condition, error) {
+    if (!condition) {
+        throw new Error(error || 'Unspecified AssertionError');
+    }
+}
+exports.assert = assert;

package/src/dlob/DLOB.ts

@@ -24,6 +24,8 @@ import {
 	isTriggered,
 	getLimitPrice,
 	UserMap,
+	OrderRecord,
+	OrderActionRecord,
 } from '..';
 import { PublicKey } from '@solana/web3.js';
 import { DLOBNode, DLOBNodeType, TriggerOrderNode } from '..';
@@ -131,6 +133,68 @@ export class DLOB {
 		return true;
 	}
 
+	public handleOrderRecord(record: OrderRecord): void {
+		this.insertOrder(record.order, record.user);
+	}
+
+	public handleOrderActionRecord(record: OrderActionRecord): void {
+		if (isOneOfVariant(record.action, ['place', 'expire'])) {
+			return;
+		}
+
+		if (isVariant(record.action, 'trigger')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.trigger(takerOrder, record.taker);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.trigger(makerOrder, record.maker);
+				}
+			}
+		} else if (isVariant(record.action, 'fill')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.updateOrder(
+						takerOrder,
+						record.taker,
+						record.takerOrderCumulativeBaseAssetAmountFilled
+					);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.updateOrder(
+						makerOrder,
+						record.maker,
+						record.makerOrderCumulativeBaseAssetAmountFilled
+					);
+				}
+			}
+		} else if (isVariant(record.action, 'cancel')) {
+			if (record.taker !== null) {
+				const takerOrder = this.getOrder(record.takerOrderId, record.taker);
+				if (takerOrder) {
+					this.delete(takerOrder, record.taker);
+				}
+			}
+
+			if (record.maker !== null) {
+				const makerOrder = this.getOrder(record.makerOrderId, record.maker);
+				if (makerOrder) {
+					this.delete(makerOrder, record.maker);
+				}
+			}
+		}
+	}
+
 	public insertOrder(
 		order: Order,
 		userAccount: PublicKey,
@@ -179,6 +243,29 @@ export class DLOB {
 		});
 	}
 
+	public updateOrder(
+		order: Order,
+		userAccount: PublicKey,
+		cumulativeBaseAssetAmountFilled: BN,
+		onUpdate?: OrderBookCallback
+	): void {
+		if (order.baseAssetAmount.eq(cumulativeBaseAssetAmountFilled)) {
+			this.delete(order, userAccount);
+			return;
+		}
+
+		if (order.baseAssetAmountFilled.eq(cumulativeBaseAssetAmountFilled)) {
+			return;
+		}
+
+		order.baseAssetAmountFilled = cumulativeBaseAssetAmountFilled;
+		this.getListForOrder(order)?.update(order, userAccount);
+
+		if (onUpdate) {
+			onUpdate();
+		}
+	}
+
 	public trigger(
 		order: Order,
 		userAccount: PublicKey,
@@ -188,6 +275,10 @@ export class DLOB {
 			return;
 		}
 
+		if (isTriggered(order)) {
+			return;
+		}
+
 		const marketType = getVariant(order.marketType) as MarketTypeStr;
 
 		const triggerList = this.orderLists.get(marketType).get(order.marketIndex)
@@ -200,6 +291,21 @@ export class DLOB {
 		}
 	}
 
+	public delete(
+		order: Order,
+		userAccount: PublicKey,
+		onDelete?: OrderBookCallback
+	): void {
+		if (isVariant(order.status, 'init')) {
+			return;
+		}
+
+		this.getListForOrder(order)?.remove(order, userAccount);
+		if (onDelete) {
+			onDelete();
+		}
+	}
+
 	public getListForOrder(order: Order): NodeList<any> | undefined {
 		const isInactiveTriggerOrder =
 			mustBeTriggered(order) && !isTriggered(order);
@@ -233,6 +339,17 @@ export class DLOB {
 		];
 	}
 
+	public getOrder(orderId: number, userAccount: PublicKey): Order | undefined {
+		for (const nodeList of this.getNodeLists()) {
+			const node = nodeList.get(orderId, userAccount);
+			if (node) {
+				return node.order;
+			}
+		}
+
+		return undefined;
+	}
+
 	public findNodesToFill(
 		marketIndex: number,
 		fallbackBid: BN | undefined,
@@ -1164,86 +1281,41 @@ export class DLOB {
 	}
 
 	public getDLOBOrders(): DLOBOrders {
-		let dlobOrders: DLOBOrders = [];
-
-		for (const [marketIndex, nodeLists] of this.orderLists.get('perp')) {
-			dlobOrders = dlobOrders.concat(
-				this.getOrdersForMarket(marketIndex, MarketType.PERP, nodeLists)
-			);
-		}
+		const dlobOrders: DLOBOrders = [];
 
-		for (const [marketIndex, nodeLists] of this.orderLists.get('spot')) {
-			dlobOrders = dlobOrders.concat(
-				this.getOrdersForMarket(marketIndex, MarketType.SPOT, nodeLists)
-			);
+		for (const nodeList of this.getNodeLists()) {
+			for (const node of nodeList.getGenerator()) {
+				dlobOrders.push({
+					user: node.userAccount,
+					order: node.order,
+				});
+			}
 		}
 
 		return dlobOrders;
 	}
 
-	getOrdersForMarket(
-		marketIndex: number,
-		marketType: MarketType,
-		nodeLists: MarketNodeLists
-	): DLOBOrders {
-		const orders: { user: PublicKey; order: Order }[] = [];
-
-		for (const node of nodeLists.limit.bid.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		for (const node of nodeLists.limit.ask.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		for (const node of nodeLists.market.bid.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
+	*getNodeLists(): Generator<NodeList<DLOBNodeType>> {
+		for (const [_, nodeLists] of this.orderLists.get('perp')) {
+			yield nodeLists.limit.bid;
+			yield nodeLists.limit.ask;
+			yield nodeLists.market.bid;
+			yield nodeLists.market.ask;
+			yield nodeLists.floatingLimit.bid;
+			yield nodeLists.floatingLimit.ask;
+			yield nodeLists.trigger.above;
+			yield nodeLists.trigger.below;
 		}
 
-		for (const node of nodeLists.market.ask.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
+		for (const [_, nodeLists] of this.orderLists.get('spot')) {
+			yield nodeLists.limit.bid;
+			yield nodeLists.limit.ask;
+			yield nodeLists.market.bid;
+			yield nodeLists.market.ask;
+			yield nodeLists.floatingLimit.bid;
+			yield nodeLists.floatingLimit.ask;
+			yield nodeLists.trigger.above;
+			yield nodeLists.trigger.below;
 		}
-
-		for (const node of nodeLists.floatingLimit.bid.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		for (const node of nodeLists.floatingLimit.ask.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		for (const node of nodeLists.trigger.below.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		for (const node of nodeLists.trigger.above.getGenerator()) {
-			orders.push({
-				user: node.userAccount,
-				order: node.order,
-			});
-		}
-
-		return orders;
 	}
 }

package/src/dlob/NodeList.ts

@@ -146,6 +146,13 @@ export class NodeList<NodeType extends keyof DLOBNodeMap>
 		return this.nodeMap.has(getOrderSignature(order.orderId, userAccount));
 	}
 
+	public get(
+		orderId: number,
+		userAccount: PublicKey
+	): DLOBNodeMap[NodeType] | undefined {
+		return this.nodeMap.get(getOrderSignature(orderId, userAccount));
+	}
+
 	public print(): void {
 		let currentNode = this.head;
 		while (currentNode !== undefined) {

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

package/src/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

package/src/tx/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/tx/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInTx = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const COMPUTE_UNITS_DEFAULT = 200000;
+function wrapInTx(instruction, computeUnits = 600000 // TODO, requires less code change
+) {
+    const tx = new web3_js_1.Transaction();
+    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+        tx.add(web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: computeUnits,
+            additionalFee: 0,
+        }));
+    }
+    return tx.add(instruction);
+}
+exports.wrapInTx = wrapInTx;

package/src/util/computeUnits.js

@@ -0,0 +1,27 @@
+"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.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) 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;

package/src/util/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/src/util/tps.js

@@ -0,0 +1,27 @@
+"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.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;