@drift-labs/sdk 2.142.0-beta.2 → 2.142.0-beta.21

package/src/accounts/grpcMultiAccountSubscriber.ts

@@ -1,5 +1,5 @@
 import { Program } from '@coral-xyz/anchor';
-import { Context, PublicKey } from '@solana/web3.js';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
 import * as Buffer from 'buffer';
 import bs58 from 'bs58';
 
@@ -11,7 +11,7 @@ import {
 	SubscribeUpdate,
 	createClient,
 } from '../isomorphic/grpc';
-import { GrpcConfigs, ResubOpts } from './types';
+import { BufferAndSlot, DataAndSlot, GrpcConfigs, ResubOpts } from './types';
 
 interface AccountInfoLike {
 	owner: PublicKey;
@@ -21,13 +21,32 @@ interface AccountInfoLike {
 	rentEpoch: number;
 }
 
-export class grpcMultiAccountSubscriber<T> {
+function commitmentLevelToCommitment(
+	commitmentLevel: CommitmentLevel
+): Commitment {
+	switch (commitmentLevel) {
+		case CommitmentLevel.PROCESSED:
+			return 'processed';
+		case CommitmentLevel.CONFIRMED:
+			return 'confirmed';
+		case CommitmentLevel.FINALIZED:
+			return 'finalized';
+		default:
+			return 'confirmed';
+	}
+}
+
+export class grpcMultiAccountSubscriber<T, U = undefined> {
 	private client: Client;
 	private stream: ClientDuplexStream<SubscribeRequest, SubscribeUpdate>;
 	private commitmentLevel: CommitmentLevel;
 	private program: Program;
 	private accountName: string;
-	private decodeBufferFn?: (buffer: Buffer, pubkey?: string) => T;
+	private decodeBufferFn?: (
+		buffer: Buffer,
+		pubkey?: string,
+		accountProps?: U
+	) => T;
 	private resubOpts?: ResubOpts;
 	private onUnsubscribe?: () => Promise<void>;
 
@@ -39,9 +58,13 @@ export class grpcMultiAccountSubscriber<T> {
 	private subscribedAccounts = new Set<string>();
 	private onChangeMap = new Map<
 		string,
-		(data: T, context: Context, buffer: Buffer) => void
+		(data: T, context: Context, buffer: Buffer, accountProps: U) => void
 	>();
 
+	private dataMap = new Map<string, DataAndSlot<T>>();
+	private accountPropsMap = new Map<string, U | Array<U>>();
+	private bufferMap = new Map<string, BufferAndSlot>();
+
 	private constructor(
 		client: Client,
 		commitmentLevel: CommitmentLevel,
@@ -49,7 +72,8 @@ export class grpcMultiAccountSubscriber<T> {
 		program: Program,
 		decodeBuffer?: (buffer: Buffer, pubkey?: string) => T,
 		resubOpts?: ResubOpts,
-		onUnsubscribe?: () => Promise<void>
+		onUnsubscribe?: () => Promise<void>,
+		accountPropsMap?: Map<string, U | Array<U>>
 	) {
 		this.client = client;
 		this.commitmentLevel = commitmentLevel;
@@ -58,17 +82,19 @@ export class grpcMultiAccountSubscriber<T> {
 		this.decodeBufferFn = decodeBuffer;
 		this.resubOpts = resubOpts;
 		this.onUnsubscribe = onUnsubscribe;
+		this.accountPropsMap = accountPropsMap;
 	}
 
-	public static async create<U>(
+	public static async create<T, U = undefined>(
 		grpcConfigs: GrpcConfigs,
 		accountName: string,
 		program: Program,
-		decodeBuffer?: (buffer: Buffer, pubkey?: string) => U,
+		decodeBuffer?: (buffer: Buffer, pubkey?: string, accountProps?: U) => T,
 		resubOpts?: ResubOpts,
 		clientProp?: Client,
-		onUnsubscribe?: () => Promise<void>
-	): Promise<grpcMultiAccountSubscriber<U>> {
+		onUnsubscribe?: () => Promise<void>,
+		accountPropsMap?: Map<string, U | Array<U>>
+	): Promise<grpcMultiAccountSubscriber<T, U>> {
 		const client = clientProp
 			? clientProp
 			: await createClient(
@@ -87,19 +113,104 @@ export class grpcMultiAccountSubscriber<T> {
 			program,
 			decodeBuffer,
 			resubOpts,
-			onUnsubscribe
+			onUnsubscribe,
+			accountPropsMap
 		);
 	}
 
+	setAccountData(accountPubkey: string, data: T, slot?: number): void {
+		this.dataMap.set(accountPubkey, { data, slot });
+	}
+
+	getAccountData(accountPubkey: string): DataAndSlot<T> | undefined {
+		return this.dataMap.get(accountPubkey);
+	}
+
+	getAccountDataMap(): Map<string, DataAndSlot<T>> {
+		return this.dataMap;
+	}
+
+	async fetch(): Promise<void> {
+		try {
+			// Chunk account IDs into groups of 100 (getMultipleAccounts limit)
+			const chunkSize = 100;
+			const chunks: string[][] = [];
+			const accountIds = Array.from(this.subscribedAccounts.values());
+			for (let i = 0; i < accountIds.length; i += chunkSize) {
+				chunks.push(accountIds.slice(i, i + chunkSize));
+			}
+
+			// Process all chunks concurrently
+			await Promise.all(
+				chunks.map(async (chunk) => {
+					const accountAddresses = chunk.map(
+						(accountId) => new PublicKey(accountId)
+					);
+					const rpcResponseAndContext =
+						await this.program.provider.connection.getMultipleAccountsInfoAndContext(
+							accountAddresses,
+							{
+								commitment: commitmentLevelToCommitment(this.commitmentLevel),
+							}
+						);
+
+					const rpcResponse = rpcResponseAndContext.value;
+					const currentSlot = rpcResponseAndContext.context.slot;
+
+					for (let i = 0; i < chunk.length; i++) {
+						const accountId = chunk[i];
+						const accountInfo = rpcResponse[i];
+						if (accountInfo) {
+							const prev = this.bufferMap.get(accountId);
+							const newBuffer = accountInfo.data as Buffer;
+							if (prev && currentSlot < prev.slot) {
+								continue;
+							}
+							if (
+								prev &&
+								prev.buffer &&
+								newBuffer &&
+								newBuffer.equals(prev.buffer)
+							) {
+								continue;
+							}
+							this.bufferMap.set(accountId, {
+								buffer: newBuffer,
+								slot: currentSlot,
+							});
+
+							const accountDecoded = this.program.coder.accounts.decode(
+								this.capitalize(this.accountName),
+								newBuffer
+							);
+							this.setAccountData(accountId, accountDecoded, currentSlot);
+						}
+					}
+				})
+			);
+		} catch (error) {
+			if (this.resubOpts?.logResubMessages) {
+				console.log(
+					`[${this.accountName}] grpcMultiAccountSubscriber error fetching accounts:`,
+					error
+				);
+			}
+		}
+	}
+
 	async subscribe(
 		accounts: PublicKey[],
 		onChange: (
 			accountId: PublicKey,
 			data: T,
 			context: Context,
-			buffer: Buffer
+			buffer: Buffer,
+			accountProps: U
 		) => void
 	): Promise<void> {
+		if (this.resubOpts?.logResubMessages) {
+			console.log(`[${this.accountName}] grpcMultiAccountSubscriber subscribe`);
+		}
 		if (this.listenerId != null || this.isUnsubscribing) {
 			return;
 		}
@@ -108,9 +219,10 @@ export class grpcMultiAccountSubscriber<T> {
 		for (const pk of accounts) {
 			const key = pk.toBase58();
 			this.subscribedAccounts.add(key);
-			this.onChangeMap.set(key, (data, ctx, buffer) =>
-				onChange(new PublicKey(key), data, ctx, buffer)
-			);
+			this.onChangeMap.set(key, (data, ctx, buffer, accountProps) => {
+				this.setAccountData(key, data, ctx.slot);
+				onChange(new PublicKey(key), data, ctx, buffer, accountProps);
+			});
 		}
 
 		this.stream =
@@ -145,6 +257,19 @@ export class grpcMultiAccountSubscriber<T> {
 			if (!accountPubkey || !this.subscribedAccounts.has(accountPubkey)) {
 				return;
 			}
+
+			// Touch resub timer on any incoming account update for subscribed keys
+			if (this.resubOpts?.resubTimeoutMs) {
+				this.receivingData = true;
+				clearTimeout(this.timeoutId);
+				this.setTimeout();
+			}
+
+			// Skip processing if we already have data for this account at a newer slot
+			const existing = this.dataMap.get(accountPubkey);
+			if (existing?.slot !== undefined && existing.slot > slot) {
+				return;
+			}
 			const accountInfo: AccountInfoLike = {
 				owner: new PublicKey(chunk.account.account.owner),
 				lamports: Number(chunk.account.account.lamports),
@@ -155,23 +280,46 @@ export class grpcMultiAccountSubscriber<T> {
 
 			const context = { slot } as Context;
 			const buffer = accountInfo.data;
-			const data = this.decodeBufferFn
-				? this.decodeBufferFn(buffer, accountPubkey)
-				: this.program.account[this.accountName].coder.accounts.decode(
-						this.capitalize(this.accountName),
-						buffer
-				  );
-
-			const handler = this.onChangeMap.get(accountPubkey);
-			if (handler) {
-				if (this.resubOpts?.resubTimeoutMs) {
-					this.receivingData = true;
-					clearTimeout(this.timeoutId);
-					handler(data, context, buffer);
-					this.setTimeout();
-				} else {
-					handler(data, context, buffer);
+
+			// Check existing buffer for this account and skip if unchanged or slot regressed
+			const prevBuffer = this.bufferMap.get(accountPubkey);
+			if (prevBuffer && slot < prevBuffer.slot) {
+				return;
+			}
+			if (
+				prevBuffer &&
+				prevBuffer.buffer &&
+				buffer &&
+				buffer.equals(prevBuffer.buffer)
+			) {
+				return;
+			}
+			this.bufferMap.set(accountPubkey, { buffer, slot });
+			const accountProps = this.accountPropsMap?.get(accountPubkey);
+
+			const handleDataBuffer = (
+				context: Context,
+				buffer: Buffer,
+				accountProps: U
+			) => {
+				const data = this.decodeBufferFn
+					? this.decodeBufferFn(buffer, accountPubkey, accountProps)
+					: this.program.account[this.accountName].coder.accounts.decode(
+							this.capitalize(this.accountName),
+							buffer
+					  );
+				const handler = this.onChangeMap.get(accountPubkey);
+				if (handler) {
+					handler(data, context, buffer, accountProps);
+				}
+			};
+
+			if (Array.isArray(accountProps)) {
+				for (const props of accountProps) {
+					handleDataBuffer(context, buffer, props);
 				}
+			} else {
+				handleDataBuffer(context, buffer, accountProps);
 			}
 		});
 
@@ -181,7 +329,6 @@ export class grpcMultiAccountSubscriber<T> {
 					this.listenerId = 1;
 					if (this.resubOpts?.resubTimeoutMs) {
 						this.receivingData = true;
-						this.setTimeout();
 					}
 					resolve();
 				} else {

package/src/adminClient.ts

@@ -4835,4 +4835,38 @@ export class AdminClient extends DriftClient {
 			}
 		);
 	}
+
+	public async adminDisableUpdatePerpBidAskTwap(
+		authority: PublicKey,
+		disable: boolean
+	): Promise<TransactionSignature> {
+		const disableBidAskTwapUpdateIx =
+			await this.getAdminDisableUpdatePerpBidAskTwapIx(authority, disable);
+
+		const tx = await this.buildTransaction(disableBidAskTwapUpdateIx);
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getAdminDisableUpdatePerpBidAskTwapIx(
+		authority: PublicKey,
+		disable: boolean
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.adminDisableUpdatePerpBidAskTwap(
+			disable,
+			{
+				accounts: {
+					admin: this.useHotWalletAdmin
+						? this.wallet.publicKey
+						: this.getStateAccount().admin,
+					state: await this.getStatePublicKey(),
+					userStats: getUserStatsAccountPublicKey(
+						this.program.programId,
+						authority
+					),
+				},
+			}
+		);
+	}
 }

package/src/constants/spotMarkets.ts

@@ -39,8 +39,8 @@ export const DevnetSpotMarkets: SpotMarketConfig[] = [
 		symbol: 'USDC',
 		marketIndex: 0,
 		poolId: 0,
-		oracle: new PublicKey('En8hkHLkRe9d9DraYmBTrus518BvmVH448YcvmrFM6Ce'),
-		oracleSource: OracleSource.PYTH_STABLE_COIN_PULL,
+		oracle: new PublicKey('9VCioxmni2gDLv11qufWzT3RDERhQE4iY5Gf7NTfYyAV'),
+		oracleSource: OracleSource.PYTH_LAZER_STABLE_COIN,
 		mint: new PublicKey('8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2'),
 		precision: new BN(10).pow(SIX),
 		precisionExp: SIX,
@@ -52,8 +52,8 @@ export const DevnetSpotMarkets: SpotMarketConfig[] = [
 		symbol: 'SOL',
 		marketIndex: 1,
 		poolId: 0,
-		oracle: new PublicKey('BAtFj4kQttZRVep3UZS2aZRDixkGYgWsbqTBVDbnSsPF'),
-		oracleSource: OracleSource.PYTH_PULL,
+		oracle: new PublicKey('3m6i4RFWEDw2Ft4tFHPJtYgmpPe21k56M3FHeWYrgGBz'),
+		oracleSource: OracleSource.PYTH_LAZER,
 		mint: new PublicKey(WRAPPED_SOL_MINT),
 		precision: LAMPORTS_PRECISION,
 		precisionExp: LAMPORTS_EXP,

package/src/driftClient.ts

@@ -1373,6 +1373,16 @@ export class DriftClient {
 		});
 	}
 
+	/**
+	 * Creates the transaction to add or update an approved builder.
+	 * This allows the builder to receive revenue share from referrals.
+	 *
+	 * @param builder - The public key of the builder to add or update.
+	 * @param maxFeeTenthBps - The maximum fee tenth bps to set for the builder.
+	 * @param add - Whether to add or update the builder. If the builder already exists, `add = true` will update the `maxFeeTenthBps`, otherwise it will add the builder. If `add = false`, the builder's `maxFeeTenthBps` will be set to 0.
+	 * @param txParams - The transaction parameters to use for the transaction.
+	 * @returns The transaction to add or update an approved builder.
+	 */
 	public async changeApprovedBuilder(
 		builder: PublicKey,
 		maxFeeTenthBps: number,
@@ -1389,6 +1399,15 @@ export class DriftClient {
 		return txSig;
 	}
 
+	/**
+	 * Creates the transaction instruction to add or update an approved builder.
+	 * This allows the builder to receive revenue share from referrals.
+	 *
+	 * @param builder - The public key of the builder to add or update.
+	 * @param maxFeeTenthBps - The maximum fee tenth bps to set for the builder.
+	 * @param add - Whether to add or update the builder. If the builder already exists, `add = true` will update the `maxFeeTenthBps`, otherwise it will add the builder. If `add = false`, the builder's `maxFeeTenthBps` will be set to 0.
+	 * @returns The transaction instruction to add or update an approved builder.
+	 */
 	public async getChangeApprovedBuilderIx(
 		builder: PublicKey,
 		maxFeeTenthBps: number,
@@ -4924,7 +4943,10 @@ export class DriftClient {
 
 	public async getPlaceOrdersIx(
 		params: OptionalOrderParams[],
-		subAccountId?: number
+		subAccountId?: number,
+		overrides?: {
+			authority?: PublicKey;
+		}
 	): Promise<TransactionInstruction> {
 		const user = await this.getUserAccountPublicKey(subAccountId);
 
@@ -4959,13 +4981,14 @@ export class DriftClient {
 		}
 
 		const formattedParams = params.map((item) => getOrderParams(item));
+		const authority = overrides?.authority ?? this.wallet.publicKey;
 
 		return await this.program.instruction.placeOrders(formattedParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user,
 				userStats: this.getUserStatsAccountPublicKey(),
-				authority: this.wallet.publicKey,
+				authority,
 			},
 			remainingAccounts,
 		});
@@ -6669,7 +6692,10 @@ export class DriftClient {
 		referrerInfo?: ReferrerInfo,
 		successCondition?: PlaceAndTakeOrderSuccessCondition,
 		auctionDurationPercentage?: number,
-		subAccountId?: number
+		subAccountId?: number,
+		overrides?: {
+			authority?: PublicKey;
+		}
 	): Promise<TransactionInstruction> {
 		orderParams = getOrderParams(orderParams, { marketType: MarketType.PERP });
 		const userStatsPublicKey = await this.getUserStatsAccountPublicKey();
@@ -6737,6 +6763,8 @@ export class DriftClient {
 				((auctionDurationPercentage ?? 100) << 8) | (successCondition ?? 0);
 		}
 
+		const authority = overrides?.authority ?? this.wallet.publicKey;
+
 		return await this.program.instruction.placeAndTakePerpOrder(
 			orderParams,
 			optionalParams,
@@ -6745,7 +6773,7 @@ export class DriftClient {
 					state: await this.getStatePublicKey(),
 					user,
 					userStats: userStatsPublicKey,
-					authority: this.wallet.publicKey,
+					authority,
 				},
 				remainingAccounts,
 			}

package/src/events/types.ts

@@ -24,6 +24,7 @@ import {
 	LPMintRedeemRecord,
 	LPSettleRecord,
 	LPSwapRecord,
+	LPBorrowLendDepositRecord,
 } from '../types';
 import { EventEmitter } from 'events';
 
@@ -116,8 +117,8 @@ export type EventMap = {
 	FuelSeasonRecord: Event<FuelSeasonRecord>;
 	InsuranceFundSwapRecord: Event<InsuranceFundSwapRecord>;
 	TransferProtocolIfSharesToRevenuePoolRecord: Event<TransferProtocolIfSharesToRevenuePoolRecord>;
-	LPMintRedeemRecord: Event<LPMintRedeemRecord>;
 	LPSettleRecord: Event<LPSettleRecord>;
+	LPMintRedeemRecord: Event<LPMintRedeemRecord>;
 	LPSwapRecord: Event<LPSwapRecord>;
 };
 
@@ -146,8 +147,9 @@ export type DriftEvent =
 	| Event<InsuranceFundSwapRecord>
 	| Event<TransferProtocolIfSharesToRevenuePoolRecord>
 	| Event<LPSettleRecord>
+	| Event<LPMintRedeemRecord>
 	| Event<LPSwapRecord>
-	| Event<LPMintRedeemRecord>;
+	| Event<LPBorrowLendDepositRecord>;
 
 export interface EventSubscriberEvents {
 	newEvent: (event: WrappedEvent<EventType>) => void;

package/src/idl/drift.json

@@ -14875,6 +14875,11 @@
           "name": "lpPrice",
           "type": "u128",
           "index": false
+        },
+        {
+          "name": "lpPool",
+          "type": "publicKey",
+          "index": false
         }
       ]
     },
@@ -14985,6 +14990,11 @@
           "name": "outSwapId",
           "type": "u64",
           "index": false
+        },
+        {
+          "name": "lpPool",
+          "type": "publicKey",
+          "index": false
         }
       ]
     },
@@ -15080,6 +15090,68 @@
           "name": "inMarketTargetWeight",
           "type": "i64",
           "index": false
+        },
+        {
+          "name": "lpPool",
+          "type": "publicKey",
+          "index": false
+        }
+      ]
+    },
+    {
+      "name": "LPBorrowLendDepositRecord",
+      "fields": [
+        {
+          "name": "ts",
+          "type": "i64",
+          "index": false
+        },
+        {
+          "name": "slot",
+          "type": "u64",
+          "index": false
+        },
+        {
+          "name": "spotMarketIndex",
+          "type": "u16",
+          "index": false
+        },
+        {
+          "name": "constituentIndex",
+          "type": "u16",
+          "index": false
+        },
+        {
+          "name": "direction",
+          "type": {
+            "defined": "DepositDirection"
+          },
+          "index": false
+        },
+        {
+          "name": "tokenBalance",
+          "type": "i64",
+          "index": false
+        },
+        {
+          "name": "lastTokenBalance",
+          "type": "i64",
+          "index": false
+        },
+        {
+          "name": "interestAccruedTokenAmount",
+          "type": "i64",
+          "index": false
+        },
+        {
+          "name": "amountDepositWithdraw",
+          "type": "u64",
+          "index": false
+        },
+        {
+          "name": "lpPool",
+          "type": "publicKey",
+          "index": false
         }
       ]
     }

package/src/types.ts

@@ -767,6 +767,7 @@ export type LPSwapRecord = {
 	outMarketTargetWeight: BN;
 	inSwapId: BN;
 	outSwapId: BN;
+	lpPool: PublicKey;
 };
 
 export type LPMintRedeemRecord = {
@@ -789,6 +790,7 @@ export type LPMintRedeemRecord = {
 	lastAumSlot: BN;
 	inMarketCurrentWeight: BN;
 	inMarketTargetWeight: BN;
+	lpPool: PublicKey;
 };
 
 export type LPSettleRecord = {
@@ -803,6 +805,20 @@ export type LPSettleRecord = {
 	perpAmmExFeeDelta: BN;
 	lpAum: BN;
 	lpPrice: BN;
+	lpPool: PublicKey;
+};
+
+export type LPBorrowLendDepositRecord = {
+	ts: BN;
+	slot: BN;
+	spotMarketIndex: number;
+	constituentIndex: number;
+	direction: DepositDirection;
+	tokenBalance: BN;
+	lastTokenBalance: BN;
+	interestAccruedTokenAmount: BN;
+	amountDepositWithdraw: BN;
+	lpPool: PublicKey;
 };
 
 export type StateAccount = {
@@ -878,6 +894,11 @@ export type PerpMarketAccount = {
 	protectedMakerLimitPriceDivisor: number;
 	protectedMakerDynamicDivisor: number;
 	lastFillPrice: BN;
+
+	lpFeeTransferScalar: number;
+	lpExchangeFeeExcluscionScalar: number;
+	lpStatus: number;
+	lpPausedOperations: number;
 };
 
 export type HistoricalOracleData = {
@@ -1669,13 +1690,15 @@ export type RevenueShareEscrowAccount = {
 };
 
 export type RevenueShareOrder = {
-	builderIdx: number;
 	feesAccrued: BN;
 	orderId: number;
 	feeTenthBps: number;
 	marketIndex: number;
+	subAccountId: number;
+	builderIdx: number;
 	bitFlags: number;
-	marketType: MarketType; // 0: spot, 1: perp
+	userOrderIndex: number;
+	marketType: MarketType;
 	padding: number[];
 };