@drift-labs/sdk 2.49.0-beta.16 → 2.49.0-beta.17

package/lib/userMap/userMap.js

@@ -7,12 +7,13 @@ const buffer_1 = require("buffer");
 const memcmp_1 = require("../memcmp");
 const WebsocketSubscription_1 = require("./WebsocketSubscription");
 const PollingSubscription_1 = require("./PollingSubscription");
+const user_1 = require("../decode/user");
 class UserMap {
     /**
      * Constructs a new UserMap instance.
      */
     constructor(config) {
-        var _a, _b;
+        var _a, _b, _c;
         this.userMap = new Map();
         this.stateAccountUpdateCallback = async (state) => {
             if (!state.numberOfSubAccounts.eq(this.lastNumberOfSubAccounts)) {
@@ -30,6 +31,15 @@ class UserMap {
         this.commitment =
             (_a = config.subscriptionConfig.commitment) !== null && _a !== void 0 ? _a : this.driftClient.opts.commitment;
         this.includeIdle = (_b = config.includeIdle) !== null && _b !== void 0 ? _b : false;
+        let decodeFn;
+        if ((_c = config.fastDecode) !== null && _c !== void 0 ? _c : true) {
+            decodeFn = (name, buffer) => (0, user_1.decodeUser)(buffer);
+        }
+        else {
+            decodeFn =
+                this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(this.driftClient.program.account.user.coder.accounts);
+        }
+        this.decode = decodeFn;
         if (config.subscriptionConfig.type === 'polling') {
             this.subscription = new PollingSubscription_1.PollingSubscription({
                 userMap: this,
@@ -43,6 +53,7 @@ class UserMap {
                 commitment: this.commitment,
                 resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
                 skipInitialLoad: config.skipInitialLoad,
+                decodeFn,
             });
         }
     }
@@ -215,8 +226,9 @@ class UserMap {
             }
             for (const [key, buffer] of programAccountBufferMap.entries()) {
                 if (!this.has(key)) {
-                    const userAccount = this.driftClient.program.account.user.coder.accounts.decodeUnchecked('User', buffer);
+                    const userAccount = this.decode('User', buffer);
                     await this.addPubkey(new web3_js_1.PublicKey(key), userAccount);
+                    this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
                 }
                 // give event loop a chance to breathe
                 await new Promise((resolve) => setTimeout(resolve, 0));
@@ -226,10 +238,6 @@ class UserMap {
                     await user.unsubscribe();
                     this.userMap.delete(key);
                 }
-                else {
-                    const userAccount = this.driftClient.program.account.user.coder.accounts.decodeUnchecked('User', programAccountBufferMap.get(key));
-                    user.accountSubscriber.updateData(userAccount, slot);
-                }
                 // give event loop a chance to breathe
                 await new Promise((resolve) => setTimeout(resolve, 0));
             }

package/lib/userMap/userMapConfig.d.ts

@@ -17,4 +17,5 @@ export type UserMapConfig = {
     };
     skipInitialLoad?: boolean;
     includeIdle?: boolean;
+    fastDecode?: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.49.0-beta.16",
+	"version": "2.49.0-beta.17",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -44,6 +44,7 @@
 		"uuid": "^8.3.2"
 	},
 	"devDependencies": {
+		"object-sizeof": "^2.6.3",
 		"@types/big.js": "^6.2.0",
 		"@types/bn.js": "^5.1.3",
 		"@types/chai": "^4.3.1",

package/src/adminClient.ts

@@ -846,6 +846,20 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updateStateMaxInitializeUserFee(
+		maxInitializeUserFee: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateStateMaxInitializeUserFee(
+			maxInitializeUserFee,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateWithdrawGuardThreshold(
 		spotMarketIndex: number,
 		withdrawGuardThreshold: BN

package/src/decode/user.ts

@@ -0,0 +1,357 @@
+import {
+	MarketType,
+	Order,
+	OrderStatus,
+	OrderTriggerCondition,
+	OrderType,
+	PerpPosition,
+	PositionDirection,
+	SpotBalanceType,
+	SpotPosition,
+	UserAccount,
+} from '../types';
+import { PublicKey } from '@solana/web3.js';
+import { BN } from '../';
+import { ZERO } from '../';
+
+function readUnsignedBigInt64LE(buffer: Buffer, offset: number): BN {
+	return new BN(buffer.subarray(offset, offset + 8), 10, 'le');
+}
+
+function readSignedBigInt64LE(buffer: Buffer, offset: number): BN {
+	const unsignedValue = new BN(buffer.subarray(offset, offset + 8), 10, 'le');
+	if (unsignedValue.testn(63)) {
+		const inverted = unsignedValue.notn(64).addn(1);
+		return inverted.neg();
+	} else {
+		return unsignedValue;
+	}
+}
+
+export function decodeUser(buffer: Buffer): UserAccount {
+	let offset = 8;
+	const authority = new PublicKey(buffer.slice(offset, offset + 32));
+	offset += 32;
+	const delegate = new PublicKey(buffer.slice(offset, offset + 32));
+	offset += 32;
+	const name = [];
+	for (let i = 0; i < 32; i++) {
+		name.push(buffer.readUint8(offset + i));
+	}
+	offset += 32;
+
+	const spotPositions: SpotPosition[] = [];
+	for (let i = 0; i < 8; i++) {
+		const scaledBalance = readUnsignedBigInt64LE(buffer, offset);
+		const openOrders = buffer.readUInt8(offset + 35);
+		if (scaledBalance.eq(ZERO) && openOrders === 0) {
+			offset += 40;
+			continue;
+		}
+
+		offset += 8;
+		const openBids = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const openAsks = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const cumulativeDeposits = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const marketIndex = buffer.readUInt16LE(offset);
+		offset += 2;
+		const balanceTypeNum = buffer.readUInt8(offset);
+		let balanceType: SpotBalanceType;
+		if (balanceTypeNum === 0) {
+			balanceType = SpotBalanceType.DEPOSIT;
+		} else {
+			balanceType = SpotBalanceType.BORROW;
+		}
+		offset += 6;
+		spotPositions.push({
+			scaledBalance,
+			openBids,
+			openAsks,
+			cumulativeDeposits,
+			marketIndex,
+			balanceType,
+			openOrders,
+		});
+	}
+
+	const perpPositions: PerpPosition[] = [];
+	for (let i = 0; i < 8; i++) {
+		const baseAssetAmount = readSignedBigInt64LE(buffer, offset + 8);
+		const quoteAssetAmount = readSignedBigInt64LE(buffer, offset + 16);
+		const lpShares = readUnsignedBigInt64LE(buffer, offset + 64);
+		const openOrders = buffer.readUInt8(offset + 94);
+
+		if (
+			baseAssetAmount.eq(ZERO) &&
+			openOrders === 0 &&
+			quoteAssetAmount.eq(ZERO) &&
+			lpShares.eq(ZERO)
+		) {
+			offset += 96;
+			continue;
+		}
+
+		const lastCumulativeFundingRate = readSignedBigInt64LE(buffer, offset);
+		offset += 24;
+		const quoteBreakEvenAmount = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const quoteEntryAmount = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const openBids = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const openAsks = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const settledPnl = readSignedBigInt64LE(buffer, offset);
+		offset += 16;
+		const lastBaseAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const lastQuoteAssetAmountPerLp = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const remainderBaseAssetAmount = buffer.readUint32LE(offset);
+		offset += 4;
+		const marketIndex = buffer.readUInt16LE(offset);
+		offset += 3;
+		const perLpBase = buffer.readUInt8(offset);
+		offset += 1;
+
+		perpPositions.push({
+			lastCumulativeFundingRate,
+			baseAssetAmount,
+			quoteAssetAmount,
+			quoteBreakEvenAmount,
+			quoteEntryAmount,
+			openBids,
+			openAsks,
+			settledPnl,
+			lpShares,
+			lastBaseAssetAmountPerLp,
+			lastQuoteAssetAmountPerLp,
+			remainderBaseAssetAmount,
+			marketIndex,
+			openOrders,
+			perLpBase,
+		});
+	}
+
+	const orders: Order[] = [];
+	for (let i = 0; i < 32; i++) {
+		// skip order if it's not open
+		if (buffer.readUint8(offset + 82) === 0) {
+			offset += 96;
+			continue;
+		}
+
+		const slot = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const price = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const baseAssetAmount = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const baseAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const quoteAssetAmountFilled = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const triggerPrice = readUnsignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const auctionStartPrice = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const auctionEndPrice = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const maxTs = readSignedBigInt64LE(buffer, offset);
+		offset += 8;
+		const oraclePriceOffset = buffer.readInt32LE(offset);
+		offset += 4;
+		const orderId = buffer.readUInt32LE(offset);
+		offset += 4;
+		const marketIndex = buffer.readUInt16LE(offset);
+		offset += 2;
+		const orderStatusNum = buffer.readUInt8(offset);
+
+		let status: OrderStatus;
+		if (orderStatusNum === 0) {
+			status = OrderStatus.INIT;
+		} else if (orderStatusNum === 1) {
+			status = OrderStatus.OPEN;
+		}
+		offset += 1;
+		const orderTypeNum = buffer.readUInt8(offset);
+		let orderType: OrderType;
+		if (orderTypeNum === 0) {
+			orderType = OrderType.MARKET;
+		} else if (orderTypeNum === 1) {
+			orderType = OrderType.LIMIT;
+		} else if (orderTypeNum === 2) {
+			orderType = OrderType.TRIGGER_MARKET;
+		} else if (orderTypeNum === 3) {
+			orderType = OrderType.TRIGGER_LIMIT;
+		} else if (orderTypeNum === 4) {
+			orderType = OrderType.ORACLE;
+		}
+		offset += 1;
+		const marketTypeNum = buffer.readUInt8(offset);
+		let marketType: MarketType;
+		if (marketTypeNum === 0) {
+			marketType = MarketType.SPOT;
+		} else {
+			marketType = MarketType.PERP;
+		}
+		offset += 1;
+		const userOrderId = buffer.readUint8(offset);
+		offset += 1;
+		const existingPositionDirectionNum = buffer.readUInt8(offset);
+		let existingPositionDirection: PositionDirection;
+		if (existingPositionDirectionNum === 0) {
+			existingPositionDirection = PositionDirection.LONG;
+		} else {
+			existingPositionDirection = PositionDirection.SHORT;
+		}
+		offset += 1;
+		const positionDirectionNum = buffer.readUInt8(offset);
+		let direction: PositionDirection;
+		if (positionDirectionNum === 0) {
+			direction = PositionDirection.LONG;
+		} else {
+			direction = PositionDirection.SHORT;
+		}
+		offset += 1;
+		const reduceOnly = buffer.readUInt8(offset) === 1;
+		offset += 1;
+		const postOnly = buffer.readUInt8(offset) === 1;
+		offset += 1;
+		const immediateOrCancel = buffer.readUInt8(offset) === 1;
+		offset += 1;
+		const triggerConditionNum = buffer.readUInt8(offset);
+		let triggerCondition: OrderTriggerCondition;
+		if (triggerConditionNum === 0) {
+			triggerCondition = OrderTriggerCondition.ABOVE;
+		} else if (triggerConditionNum === 1) {
+			triggerCondition = OrderTriggerCondition.BELOW;
+		} else if (triggerConditionNum === 2) {
+			triggerCondition = OrderTriggerCondition.TRIGGERED_ABOVE;
+		} else if (triggerConditionNum === 3) {
+			triggerCondition = OrderTriggerCondition.TRIGGERED_BELOW;
+		}
+		offset += 1;
+		const auctionDuration = buffer.readUInt8(offset);
+		offset += 1;
+		offset += 3; // padding
+		orders.push({
+			slot,
+			price,
+			baseAssetAmount,
+			baseAssetAmountFilled,
+			quoteAssetAmountFilled,
+			triggerPrice,
+			auctionStartPrice,
+			auctionEndPrice,
+			maxTs,
+			oraclePriceOffset,
+			orderId,
+			marketIndex,
+			status,
+			orderType,
+			marketType,
+			userOrderId,
+			existingPositionDirection,
+			direction,
+			reduceOnly,
+			postOnly,
+			immediateOrCancel,
+			triggerCondition,
+			auctionDuration,
+		});
+	}
+
+	const lastAddPerpLpSharesTs = readSignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const totalDeposits = readUnsignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const totalWithdraws = readUnsignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const totalSocialLoss = readUnsignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const settledPerpPnl = readSignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const cumulativeSpotFees = readSignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const cumulativePerpFunding = readSignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const liquidationMarginFreed = readUnsignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const lastActiveSlot = readUnsignedBigInt64LE(buffer, offset);
+	offset += 8;
+
+	const nextOrderId = buffer.readUInt32LE(offset);
+	offset += 4;
+
+	const maxMarginRatio = buffer.readUInt32LE(offset);
+	offset += 4;
+
+	const nextLiquidationId = buffer.readUInt16LE(offset);
+	offset += 2;
+
+	const subAccountId = buffer.readUInt16LE(offset);
+	offset += 2;
+
+	const status = buffer.readUInt8(offset);
+	offset += 1;
+
+	const isMarginTradingEnabled = buffer.readUInt8(offset) === 1;
+	offset += 1;
+
+	const idle = buffer.readUInt8(offset) === 1;
+	offset += 1;
+
+	const openOrders = buffer.readUInt8(offset);
+	offset += 1;
+
+	const hasOpenOrder = buffer.readUInt8(offset) === 1;
+	offset += 1;
+
+	const openAuctions = buffer.readUInt8(offset);
+	offset += 1;
+
+	const hasOpenAuction = buffer.readUInt8(offset) === 1;
+	offset += 1;
+
+	// @ts-ignore
+	return {
+		authority,
+		delegate,
+		name,
+		spotPositions,
+		perpPositions,
+		orders,
+		lastAddPerpLpSharesTs,
+		totalDeposits,
+		totalWithdraws,
+		totalSocialLoss,
+		settledPerpPnl,
+		cumulativeSpotFees,
+		cumulativePerpFunding,
+		liquidationMarginFreed,
+		lastActiveSlot,
+		nextOrderId,
+		maxMarginRatio,
+		nextLiquidationId,
+		subAccountId,
+		status,
+		isMarginTradingEnabled,
+		idle,
+		openOrders,
+		hasOpenOrder,
+		openAuctions,
+		hasOpenAuction,
+	};
+}

package/src/idl/drift.json

@@ -4184,6 +4184,27 @@
         }
       ]
     },
+    {
+      "name": "updateStateMaxInitializeUserFee",
+      "accounts": [
+        {
+          "name": "admin",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "state",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": [
+        {
+          "name": "maxInitializeUserFee",
+          "type": "u16"
+        }
+      ]
+    },
     {
       "name": "updatePerpMarketOracle",
       "accounts": [
@@ -5747,12 +5768,16 @@
             "name": "maxNumberOfSubAccounts",
             "type": "u16"
           },
+          {
+            "name": "maxInitializeUserFee",
+            "type": "u16"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                12
+                10
               ]
             }
           }
@@ -11094,6 +11119,11 @@
       "code": 6255,
       "name": "InvalidMarginCalculation",
       "msg": "InvalidMarginCalculation"
+    },
+    {
+      "code": 6256,
+      "name": "CantPayUserInitFee",
+      "msg": "CantPayUserInitFee"
     }
   ]
-}
+}

package/src/index.ts

@@ -56,6 +56,7 @@ export * from './math/margin';
 export * from './math/insurance';
 export * from './math/superStake';
 export * from './math/spotPosition';
+export * from './math/state';
 export * from './marinade';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';

package/src/math/state.ts

@@ -0,0 +1,29 @@
+import { StateAccount } from '../types';
+import { BN, LAMPORTS_PRECISION, PERCENTAGE_PRECISION, ZERO } from '../';
+
+export function calculateInitUserFee(stateAccount: StateAccount): BN {
+	const maxInitFee = new BN(stateAccount.maxInitializeUserFee)
+		.mul(LAMPORTS_PRECISION)
+		.divn(100);
+	const targetUtilization = PERCENTAGE_PRECISION.muln(8).divn(10);
+
+	const accountSpaceUtilization = stateAccount.numberOfSubAccounts
+		.addn(1)
+		.mul(PERCENTAGE_PRECISION)
+		.div(getMaxNumberOfSubAccounts(stateAccount));
+
+	if (accountSpaceUtilization.gt(targetUtilization)) {
+		return maxInitFee
+			.mul(accountSpaceUtilization.sub(targetUtilization))
+			.div(PERCENTAGE_PRECISION.sub(targetUtilization));
+	} else {
+		return ZERO;
+	}
+}
+
+export function getMaxNumberOfSubAccounts(stateAccount: StateAccount): BN {
+	if (stateAccount.maxNumberOfSubAccounts <= 100) {
+		return new BN(stateAccount.maxNumberOfSubAccounts);
+	}
+	return new BN(stateAccount.maxNumberOfSubAccounts).muln(100);
+}

package/src/orderSubscriber/OrderSubscriber.ts

@@ -10,6 +10,7 @@ import { WebsocketSubscription } from './WebsocketSubscription';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { BN } from '../index';
+import { decodeUser } from '../decode/user';
 
 export class OrderSubscriber {
 	driftClient: DriftClient;
@@ -22,6 +23,7 @@ export class OrderSubscriber {
 	fetchPromiseResolver: () => void;
 
 	mostRecentSlot: number;
+	decodeFn: (name: string, data: Buffer) => UserAccount;
 
 	constructor(config: OrderSubscriberConfig) {
 		this.driftClient = config.driftClient;
@@ -39,6 +41,14 @@ export class OrderSubscriber {
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
 		}
+		if (config.fastDecode ?? true) {
+			this.decodeFn = (name, data) => decodeUser(data);
+		} else {
+			this.decodeFn =
+				this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.driftClient.program.account.user.coder.accounts
+				);
+		}
 		this.eventEmitter = new EventEmitter();
 	}
 
@@ -150,11 +160,7 @@ export class OrderSubscriber {
 					return;
 				}
 
-				userAccount =
-					this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
-						'User',
-						buffer
-					) as UserAccount;
+				userAccount = this.decodeFn('User', buffer) as UserAccount;
 			} else {
 				userAccount = data as UserAccount;
 			}

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -38,9 +38,7 @@ export class WebsocketSubscription {
 			'OrderSubscriber',
 			'User',
 			this.orderSubscriber.driftClient.program,
-			this.orderSubscriber.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
-				this.orderSubscriber.driftClient.program.account.user.coder.accounts
-			),
+			this.orderSubscriber.decodeFn,
 			{
 				filters: [getUserFilter(), getNonIdleUserFilter()],
 				commitment: this.commitment,

package/src/orderSubscriber/types.ts

@@ -16,6 +16,7 @@ export type OrderSubscriberConfig = {
 				resubTimeoutMs?: number;
 				commitment?: Commitment;
 		  };
+	fastDecode?: boolean;
 };
 
 export interface OrderSubscriberEvents {

package/src/types.ts

@@ -552,6 +552,7 @@ export type StateAccount = {
 	lpCooldownTime: BN;
 	initialPctToLiquidate: number;
 	liquidationDuration: number;
+	maxInitializeUserFee: number;
 };
 
 export type PerpMarketAccount = {
@@ -870,7 +871,6 @@ export type Order = {
 	price: BN;
 	baseAssetAmount: BN;
 	baseAssetAmountFilled: BN;
-	quoteAssetAmount: BN;
 	quoteAssetAmountFilled: BN;
 	direction: PositionDirection;
 	reduceOnly: boolean;

package/src/user.ts

@@ -422,7 +422,8 @@ export class User {
 	public getPerpPositionWithLPSettle(
 		marketIndex: number,
 		originalPosition?: PerpPosition,
-		burnLpShares = false
+		burnLpShares = false,
+		includeRemainderInBaseAmount = false
 	): [PerpPosition, BN, BN] {
 		originalPosition =
 			originalPosition ??
@@ -600,7 +601,16 @@ export class User {
 			position.lastCumulativeFundingRate = ZERO;
 		}
 
-		return [position, remainderBaa, pnl];
+		const remainderBeforeRemoval = new BN(position.remainderBaseAssetAmount);
+
+		if (includeRemainderInBaseAmount) {
+			position.baseAssetAmount = position.baseAssetAmount.add(
+				remainderBeforeRemoval
+			);
+			position.remainderBaseAssetAmount = 0;
+		}
+
+		return [position, remainderBeforeRemoval, pnl];
 	}
 
 	/**

package/src/userMap/PollingSubscription.ts

@@ -27,10 +27,12 @@ export class PollingSubscription {
 			return;
 		}
 
-		this.intervalId = setInterval(
-			this.userMap.sync.bind(this.userMap),
-			this.frequency
-		);
+		if (this.frequency > 0) {
+			this.intervalId = setInterval(
+				this.userMap.sync.bind(this.userMap),
+				this.frequency
+			);
+		}
 
 		if (!this.skipInitialLoad) {
 			await this.userMap.sync();