@drift-labs/sdk 0.1.18-orders.1 → 0.1.18-orders.2

package/lib/orderParams.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarketOrderParams = exports.getStopLimitOrderParams = exports.getStopOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 const numericConstants_1 = require("./constants/numericConstants");
-function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false) {
+function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
     return {
         orderType: types_1.OrderType.LIMIT,
+        userOrderId,
         marketIndex,
         direction,
         quoteAssetAmount: numericConstants_1.ZERO,
@@ -14,18 +15,23 @@ function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, red
         reduceOnly,
         postOnly: false,
         immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
         optionalAccounts: {
             discountToken,
             referrer,
         },
         triggerCondition: types_1.OrderTriggerCondition.ABOVE,
         triggerPrice: numericConstants_1.ZERO,
+        oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false) {
+function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
     return {
         orderType: types_1.OrderType.STOP,
+        userOrderId,
         marketIndex,
         direction,
         quoteAssetAmount: numericConstants_1.ZERO,
@@ -34,18 +40,23 @@ function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPric
         reduceOnly,
         postOnly: false,
         immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
         optionalAccounts: {
             discountToken,
             referrer,
         },
         triggerCondition,
         triggerPrice,
+        oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
 exports.getStopOrderParams = getStopOrderParams;
-function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false) {
+function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
     return {
         orderType: types_1.OrderType.STOP_LIMIT,
+        userOrderId,
         marketIndex,
         direction,
         quoteAssetAmount: numericConstants_1.ZERO,
@@ -54,12 +65,16 @@ function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price,
         reduceOnly,
         postOnly: false,
         immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
         optionalAccounts: {
             discountToken,
             referrer,
         },
         triggerCondition,
         triggerPrice,
+        oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
 exports.getStopLimitOrderParams = getStopLimitOrderParams;
@@ -69,6 +84,7 @@ function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAsse
     }
     return {
         orderType: types_1.OrderType.MARKET,
+        userOrderId: 0,
         marketIndex,
         direction,
         quoteAssetAmount,
@@ -77,12 +93,16 @@ function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAsse
         reduceOnly,
         postOnly: false,
         immediateOrCancel: false,
+        positionLimit: numericConstants_1.ZERO,
+        padding0: true,
+        padding1: numericConstants_1.ZERO,
         optionalAccounts: {
             discountToken,
             referrer,
         },
         triggerCondition: types_1.OrderTriggerCondition.ABOVE,
         triggerPrice: numericConstants_1.ZERO,
+        oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
 exports.getMarketOrderParams = getMarketOrderParams;

package/lib/token/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { AccountInfo } from '@solana/spl-token';
+export declare function parseTokenAccount(data: Buffer): AccountInfo;

package/lib/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/lib/types.d.ts

@@ -97,9 +97,9 @@ export declare type DepositHistoryAccount = {
     head: BN;
     depositRecords: DepositRecord[];
 };
-export declare type CurveHistoryAccount = {
+export declare type ExtendedCurveHistoryAccount = {
     head: BN;
-    curveRecords: CurveRecord[];
+    curveRecords: ExtendedCurveRecord[];
 };
 export declare type FundingRateHistoryAccount = {
     head: BN;
@@ -131,7 +131,7 @@ export declare type DepositRecord = {
     cumulativeDepositsBefore: BN;
     amount: BN;
 };
-export declare type CurveRecord = {
+export declare type ExtendedCurveRecord = {
     ts: BN;
     recordId: BN;
     marketIndex: BN;
@@ -147,6 +147,8 @@ export declare type CurveRecord = {
     baseAssetAmountShort: BN;
     baseAssetAmount: BN;
     openInterest: BN;
+    oraclePrice: BN;
+    tradeId: BN;
 };
 export declare type TradeRecord = {
     ts: BN;
@@ -261,6 +263,7 @@ export declare type StateAccount = {
     oracleGuardRails: OracleGuardRails;
     maxDeposit: BN;
     orderState: PublicKey;
+    extendedCurveHistory: PublicKey;
 };
 export declare type OrderStateAccount = {
     orderHistory: PublicKey;
@@ -303,6 +306,7 @@ export declare type AMM = {
     totalFee: BN;
     minimumQuoteAssetTradeSize: BN;
     minimumBaseAssetTradeSize: BN;
+    lastOraclePrice: BN;
 };
 export declare type UserPosition = {
     baseAssetAmount: BN;
@@ -334,6 +338,7 @@ export declare type Order = {
     orderType: OrderType;
     ts: BN;
     orderId: BN;
+    userOrderId: number;
     marketIndex: BN;
     price: BN;
     baseAssetAmount: BN;
@@ -352,6 +357,7 @@ export declare type Order = {
 };
 export declare type OrderParams = {
     orderType: OrderType;
+    userOrderId: number;
     direction: PositionDirection;
     quoteAssetAmount: BN;
     baseAssetAmount: BN;
@@ -362,6 +368,10 @@ export declare type OrderParams = {
     immediateOrCancel: boolean;
     triggerPrice: BN;
     triggerCondition: OrderTriggerCondition;
+    positionLimit: BN;
+    oraclePriceOffset: BN;
+    padding0: boolean;
+    padding1: BN;
     optionalAccounts: {
         discountToken: boolean;
         referrer: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.18-orders.1",
+	"version": "0.1.18-orders.2",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -31,8 +31,8 @@
 		"@pythnetwork/client": "^2.5.1",
 		"@solana/spl-token": "^0.1.6",
 		"@solana/web3.js": "^1.22.0",
-		"@types/bn.js": "^5.1.0",
-		"strict-event-emitter-types": "^2.0.0"
+		"strict-event-emitter-types": "^2.0.0",
+		"uuid": "^8.3.2"
 	},
 	"description": "SDK for Drift Protocol v1",
 	"engines": {

package/src/accounts/bulkAccountLoader.ts

@@ -0,0 +1,195 @@
+import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { v4 as uuidv4 } from 'uuid';
+
+type AccountToLoad = {
+	publicKey: PublicKey;
+	callbacks: Map<string, (buffer: Buffer) => void>;
+};
+
+type AccountData = {
+	slot: number;
+	buffer: Buffer | undefined;
+};
+
+const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
+
+export class BulkAccountLoader {
+	connection: Connection;
+	commitment: Commitment;
+	pollingFrequency: number;
+	accountsToLoad = new Map<string, AccountToLoad>();
+	accountData = new Map<string, AccountData>();
+	errorCallbacks = new Map<string, (e) => void>();
+	intervalId?: NodeJS.Timer;
+
+	public constructor(
+		connection: Connection,
+		commitment: Commitment,
+		pollingFrequency: number
+	) {
+		this.connection = connection;
+		this.commitment = commitment;
+		this.pollingFrequency = pollingFrequency;
+	}
+
+	public addAccount(
+		publicKey: PublicKey,
+		callback: (buffer: Buffer) => void
+	): string {
+		const existingSize = this.accountsToLoad.size;
+
+		const callbackId = uuidv4();
+		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+		if (existingAccountToLoad) {
+			existingAccountToLoad.callbacks.set(callbackId, callback);
+		} else {
+			const callbacks = new Map<string, (buffer: Buffer) => void>();
+			callbacks.set(callbackId, callback);
+			const newAccountToLoad = {
+				publicKey,
+				callbacks,
+			};
+			this.accountsToLoad.set(publicKey.toString(), newAccountToLoad);
+		}
+
+		if (existingSize === 0) {
+			this.startPolling();
+		}
+
+		return callbackId;
+	}
+
+	public removeAccount(publicKey: PublicKey, callbackId: string): void {
+		const existingAccountToLoad = this.accountsToLoad.get(publicKey.toString());
+		if (existingAccountToLoad) {
+			existingAccountToLoad.callbacks.delete(callbackId);
+			if (existingAccountToLoad.callbacks.size === 0) {
+				this.accountsToLoad.delete(existingAccountToLoad.publicKey.toString());
+			}
+		}
+
+		if (this.accountsToLoad.size === 0) {
+			this.stopPolling();
+		}
+	}
+
+	public addErrorCallbacks(callback: (error: Error) => void): string {
+		const callbackId = uuidv4();
+		this.errorCallbacks.set(callbackId, callback);
+		return callbackId;
+	}
+
+	public removeErrorCallbacks(callbackId: string): void {
+		this.errorCallbacks.delete(callbackId);
+	}
+
+	chunks<T>(array: readonly T[], size: number): T[][] {
+		return new Array(Math.ceil(array.length / size))
+			.fill(null)
+			.map((_, index) => index * size)
+			.map((begin) => array.slice(begin, begin + size));
+	}
+
+	public async load(): Promise<void> {
+		const chunks = this.chunks(
+			Array.from(this.accountsToLoad.values()),
+			GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
+		);
+
+		await Promise.all(
+			chunks.map((chunk) => {
+				return this.loadChunk(chunk);
+			})
+		);
+	}
+
+	async loadChunk(accountsToLoad: AccountToLoad[]): Promise<void> {
+		if (accountsToLoad.length === 0) {
+			return;
+		}
+
+		const args = [
+			accountsToLoad.map((accountToLoad) => {
+				return accountToLoad.publicKey.toBase58();
+			}),
+			{ commitment: this.commitment },
+		];
+
+		let rpcResponse;
+		try {
+			// @ts-ignore
+			rpcResponse = await this.connection._rpcRequest(
+				'getMultipleAccounts',
+				args
+			);
+		} catch (e) {
+			for (const [_, callback] of this.errorCallbacks) {
+				callback(e);
+			}
+			return;
+		}
+
+		const newSlot = rpcResponse.result.context.slot;
+
+		for (const i in accountsToLoad) {
+			const accountToLoad = accountsToLoad[i];
+			const key = accountToLoad.publicKey.toString();
+			const oldRPCResponse = this.accountData.get(key);
+
+			let newBuffer: Buffer | undefined = undefined;
+			if (rpcResponse.result.value[i]) {
+				const raw: string = rpcResponse.result.value[i].data[0];
+				const dataType = rpcResponse.result.value[i].data[1];
+				newBuffer = Buffer.from(raw, dataType);
+			}
+
+			if (!oldRPCResponse) {
+				this.accountData.set(key, {
+					slot: newSlot,
+					buffer: newBuffer,
+				});
+				this.handleAccountCallbacks(accountToLoad, newBuffer);
+				continue;
+			}
+
+			if (newSlot <= oldRPCResponse.slot) {
+				continue;
+			}
+
+			const oldBuffer = oldRPCResponse.buffer;
+			if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+				this.accountData.set(key, {
+					slot: newSlot,
+					buffer: newBuffer,
+				});
+				this.handleAccountCallbacks(accountToLoad, newBuffer);
+			}
+		}
+	}
+
+	handleAccountCallbacks(accountToLoad: AccountToLoad, buffer: Buffer): void {
+		for (const [_, callback] of accountToLoad.callbacks) {
+			callback(buffer);
+		}
+	}
+
+	public getAccountData(publicKey: PublicKey): Buffer | undefined {
+		const accountData = this.accountData.get(publicKey.toString());
+		return accountData?.buffer;
+	}
+
+	public startPolling(): void {
+		if (this.intervalId) {
+			return;
+		}
+
+		this.intervalId = setInterval(this.load.bind(this), this.pollingFrequency);
+	}
+
+	public stopPolling(): void {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/accounts/bulkUserSubscription.ts

@@ -0,0 +1,28 @@
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { BulkAccountLoader } from './bulkAccountLoader';
+import { PollingUserAccountSubscriber } from './pollingUserAccountSubscriber';
+
+/**
+ * @param users
+ * @param accountLoader
+ */
+export async function bulkPollingUserSubscribe(
+	users: ClearingHouseUser[],
+	accountLoader: BulkAccountLoader
+): Promise<void> {
+	await Promise.all(
+		users.map((user) => {
+			return (
+				user.accountSubscriber as PollingUserAccountSubscriber
+			).addToAccountLoader();
+		})
+	);
+
+	await accountLoader.load();
+
+	await Promise.all(
+		users.map(async (user) => {
+			return user.subscribe();
+		})
+	);
+}