@drift-labs/sdk 2.49.0-beta.9 → 2.52.0-beta.0

package/src/decode/user.ts

@@ -0,0 +1,358 @@
+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,
+			quoteAssetAmount: undefined,
+			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/driftClient.ts

@@ -1811,6 +1811,9 @@ export class DriftClient {
 	 * @param subAccountId
 	 * @param name
 	 * @param fromSubAccountId
+	 * @param referrerInfo
+	 * @param donateAmount
+	 * @param txParams
 	 * @returns
 	 */
 	public async initializeUserAccountAndDepositCollateral(
@@ -1821,6 +1824,7 @@ export class DriftClient {
 		name?: string,
 		fromSubAccountId?: number,
 		referrerInfo?: ReferrerInfo,
+		donateAmount?: BN,
 		txParams?: TxParams
 	): Promise<[TransactionSignature, PublicKey]> {
 		const ixs = [];
@@ -1856,14 +1860,26 @@ export class DriftClient {
 			fromSubAccountId !== undefined &&
 			!isNaN(fromSubAccountId);
 
+		donateAmount = donateAmount ? donateAmount : ZERO;
+
 		const createWSOLTokenAccount =
-			isSolMarket && userTokenAccount.equals(authority) && !isFromSubaccount;
+			(isSolMarket &&
+				userTokenAccount.equals(authority) &&
+				!isFromSubaccount) ||
+			!donateAmount.eq(ZERO);
 
+		const wSolAmount = isSolMarket ? amount.add(donateAmount) : donateAmount;
+
+		let wsolTokenAccount: PublicKey;
 		if (createWSOLTokenAccount) {
 			const { ixs: startIxs, pubkey } =
-				await this.getWrappedSolAccountCreationIxs(amount, true);
+				await this.getWrappedSolAccountCreationIxs(wSolAmount, true);
 
-			userTokenAccount = pubkey;
+			wsolTokenAccount = pubkey;
+
+			if (isSolMarket) {
+				userTokenAccount = pubkey;
+			}
 
 			ixs.push(...startIxs);
 		}
@@ -1893,11 +1909,21 @@ export class DriftClient {
 		}
 		ixs.push(initializeUserAccountIx, depositCollateralIx);
 
+		if (!donateAmount.eq(ZERO)) {
+			const donateIx = await this.getDepositIntoSpotMarketRevenuePoolIx(
+				1,
+				donateAmount,
+				wsolTokenAccount
+			);
+
+			ixs.push(donateIx);
+		}
+
 		// Close the wrapped sol account at the end of the transaction
 		if (createWSOLTokenAccount) {
 			ixs.push(
 				createCloseAccountInstruction(
-					userTokenAccount,
+					wsolTokenAccount,
 					authority,
 					authority,
 					[]
@@ -5995,13 +6021,13 @@ export class DriftClient {
 		);
 	}
 
-	public async depositIntoSpotMarketRevenuePool(
+	public async getDepositIntoSpotMarketRevenuePoolIx(
 		marketIndex: number,
 		amount: BN,
 		userTokenAccountPublicKey: PublicKey
-	): Promise<TransactionSignature> {
+	): Promise<TransactionInstruction> {
 		const spotMarket = await this.getSpotMarketAccount(marketIndex);
-		const tx = await this.program.transaction.depositIntoSpotMarketRevenuePool(
+		const ix = await this.program.instruction.depositIntoSpotMarketRevenuePool(
 			amount,
 			{
 				accounts: {
@@ -6015,6 +6041,21 @@ export class DriftClient {
 			}
 		);
 
+		return ix;
+	}
+
+	public async depositIntoSpotMarketRevenuePool(
+		marketIndex: number,
+		amount: BN,
+		userTokenAccountPublicKey: PublicKey
+	): Promise<TransactionSignature> {
+		const ix = await this.getDepositIntoSpotMarketRevenuePoolIx(
+			marketIndex,
+			amount,
+			userTokenAccountPublicKey
+		);
+		const tx = await this.buildTransaction([ix]);
+
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 		return txSig;
 	}

package/src/examples/loadDlob.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider } from '@coral-xyz/anchor';
-import { DLOB, UserMap, Wallet } from '..';
+import { UserMap, Wallet } from '..';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import {
 	DriftClient,
@@ -55,17 +55,22 @@ const main = async () => {
 	await driftClient.subscribe();
 
 	console.log('Loading user map...');
-	const userMap = new UserMap(driftClient, {
-		type: 'polling',
-		accountLoader: bulkAccountLoader,
+	const userMap = new UserMap({
+		driftClient,
+		subscriptionConfig: {
+			type: 'websocket',
+			commitment: 'processed',
+		},
+		skipInitialLoad: false,
+		includeIdle: false,
 	});
 
 	// fetches all users and subscribes for updates
 	await userMap.subscribe();
 
 	console.log('Loading dlob from user map...');
-	const dlob = new DLOB();
-	await dlob.initFromUserMap(userMap, bulkAccountLoader.mostRecentSlot);
+	const slot = await driftClient.connection.getSlot();
+	const dlob = await userMap.getDLOB(slot);
 
 	console.log('number of orders', dlob.getDLOBOrders().length);
 

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.48.0",
+  "version": "2.51.0",
   "name": "drift",
   "instructions": [
     {
@@ -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

@@ -20,7 +20,7 @@ export * from './accounts/pollingTokenAccountSubscriber';
 export * from './accounts/pollingUserAccountSubscriber';
 export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/pollingInsuranceFundStakeAccountSubscriber';
-export * from './accounts/mockUserAccountSubscriber';
+export * from './accounts/basicUserAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './adminClient';
@@ -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,26 @@
+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 {
+	return new BN(stateAccount.maxNumberOfSubAccounts).muln(100);
+}