@drift-labs/sdk 2.142.0-beta.8 → 2.142.0

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 { DataAndSlot, 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,10 +58,12 @@ 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,
@@ -51,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;
@@ -60,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(
@@ -89,12 +113,13 @@ export class grpcMultiAccountSubscriber<T> {
 			program,
 			decodeBuffer,
 			resubOpts,
-			onUnsubscribe
+			onUnsubscribe,
+			accountPropsMap
 		);
 	}
 
-	setAccountData(accountPubkey: PublicKey, data: T, slot?: number): void {
-		this.dataMap.set(accountPubkey.toBase58(), { data, slot });
+	setAccountData(accountPubkey: string, data: T, slot?: number): void {
+		this.dataMap.set(accountPubkey, { data, slot });
 	}
 
 	getAccountData(accountPubkey: string): DataAndSlot<T> | undefined {
@@ -105,15 +130,87 @@ export class grpcMultiAccountSubscriber<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;
 		}
@@ -122,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 =
@@ -159,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),
@@ -169,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);
 			}
 		});
 
@@ -195,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

@@ -1232,6 +1232,46 @@ export class AdminClient extends DriftClient {
 		);
 	}
 
+	public async updatePerpMarketReferencePriceOffsetDeadbandPct(
+		perpMarketIndex: number,
+		referencePriceOffsetDeadbandPct: number
+	): Promise<TransactionSignature> {
+		const updatePerpMarketReferencePriceOffsetDeadbandPctIx =
+			await this.getUpdatePerpMarketReferencePriceOffsetDeadbandPctIx(
+				perpMarketIndex,
+				referencePriceOffsetDeadbandPct
+			);
+
+		const tx = await this.buildTransaction(
+			updatePerpMarketReferencePriceOffsetDeadbandPctIx
+		);
+
+		const { txSig } = await this.sendTransaction(tx, [], this.opts);
+
+		return txSig;
+	}
+
+	public async getUpdatePerpMarketReferencePriceOffsetDeadbandPctIx(
+		perpMarketIndex: number,
+		referencePriceOffsetDeadbandPct: number
+	): Promise<TransactionInstruction> {
+		return await this.program.instruction.updatePerpMarketReferencePriceOffsetDeadbandPct(
+			referencePriceOffsetDeadbandPct,
+			{
+				accounts: {
+					admin: this.useHotWalletAdmin
+						? this.wallet.publicKey
+						: this.getStateAccount().admin,
+					state: await this.getStatePublicKey(),
+					perpMarket: await getPerpMarketPublicKey(
+						this.program.programId,
+						perpMarketIndex
+					),
+				},
+			}
+		);
+	}
+
 	public async updatePerpMarketTargetBaseAssetAmountPerLp(
 		perpMarketIndex: number,
 		targetBaseAssetAmountPerLP: number
@@ -4835,4 +4875,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/perpMarkets.ts

@@ -1351,6 +1351,43 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 			'0xf2b3ab1c49e35e881003c3c0482d18b181a1560b697b844c24c8f85aba1cab95',
 		pythLazerId: 2316,
 	},
+	{
+		fullName: 'ZCash',
+		category: ['Privacy'],
+		symbol: 'ZEC-PERP',
+		baseAssetSymbol: 'ZEC',
+		marketIndex: 79,
+		oracle: new PublicKey('BXunfRSyiQWJHv88qMvE42mpMpksWEC8Bf13p2msnRms'),
+		launchTs: 1760366017000,
+		oracleSource: OracleSource.PYTH_LAZER,
+		pythFeedId:
+			'0xbe9b59d178f0d6a97ab4c343bff2aa69caa1eaae3e9048a65788c529b125bb24',
+		pythLazerId: 66,
+	},
+	{
+		fullName: 'Mantle',
+		category: ['L1'],
+		symbol: 'MNT-PERP',
+		baseAssetSymbol: 'MNT',
+		marketIndex: 80,
+		oracle: new PublicKey('Gy7cJ4U1nxMA44XXC3hwqkpcxEB1mZTYiwJVkaqZfU7u'),
+		launchTs: 1760366017000,
+		oracleSource: OracleSource.PYTH_LAZER,
+		pythFeedId:
+			'0x4e3037c822d852d79af3ac80e35eb420ee3b870dca49f9344a38ef4773fb0585',
+		pythLazerId: 199,
+	},
+	{
+		fullName: '1KPUMP',
+		category: ['Launchpad'],
+		symbol: '1KPUMP-PERP',
+		baseAssetSymbol: '1KPUMP',
+		marketIndex: 81,
+		oracle: new PublicKey('5r8RWTaRiMgr9Lph3FTUE3sGb1vymhpCrm83Bovjfcps'),
+		launchTs: 1760366017000,
+		oracleSource: OracleSource.PYTH_LAZER_1K,
+		pythLazerId: 1578,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

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,
@@ -4742,11 +4761,19 @@ export class DriftClient {
 		orderIds?: number[],
 		txParams?: TxParams,
 		subAccountId?: number,
-		user?: User
+		user?: User,
+		overrides?: {
+			authority?: PublicKey;
+		}
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
 			await this.buildTransaction(
-				await this.getCancelOrdersByIdsIx(orderIds, subAccountId, user),
+				await this.getCancelOrdersByIdsIx(
+					orderIds,
+					subAccountId,
+					user,
+					overrides
+				),
 				txParams
 			),
 			[],
@@ -4766,7 +4793,10 @@ export class DriftClient {
 	public async getCancelOrdersByIdsIx(
 		orderIds?: number[],
 		subAccountId?: number,
-		user?: User
+		user?: User,
+		overrides?: {
+			authority?: PublicKey;
+		}
 	): Promise<TransactionInstruction> {
 		const userAccountPubKey =
 			user?.userAccountPublicKey ??
@@ -4779,11 +4809,13 @@ export class DriftClient {
 			useMarketLastSlotCache: true,
 		});
 
+		const authority = overrides?.authority ?? this.wallet.publicKey;
+
 		return await this.program.instruction.cancelOrdersByIds(orderIds, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				user: userAccountPubKey,
-				authority: this.wallet.publicKey,
+				authority,
 			},
 			remainingAccounts,
 		});
@@ -4924,7 +4956,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 +4994,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 +6705,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 +6776,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 +6786,7 @@ export class DriftClient {
 					state: await this.getStatePublicKey(),
 					user,
 					userStats: userStatsPublicKey,
-					authority: this.wallet.publicKey,
+					authority,
 				},
 				remainingAccounts,
 			}
@@ -7608,13 +7649,19 @@ export class DriftClient {
 			policy?: number;
 		},
 		subAccountId?: number,
-		userPublicKey?: PublicKey
+		overrides?: {
+			user?: User;
+			authority?: PublicKey;
+		}
 	): Promise<TransactionInstruction> {
-		const user =
-			userPublicKey ?? (await this.getUserAccountPublicKey(subAccountId));
+		const userPubKey =
+			overrides?.user?.getUserAccountPublicKey() ??
+			(await this.getUserAccountPublicKey(subAccountId));
+		const userAccount =
+			overrides?.user?.getUserAccount() ?? this.getUserAccount(subAccountId);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount(subAccountId)],
+			userAccounts: [userAccount],
 			useMarketLastSlotCache: true,
 		});
 
@@ -7635,12 +7682,16 @@ export class DriftClient {
 			maxTs: maxTs || null,
 		};
 
+		const authority =
+			overrides?.authority ??
+			overrides?.user?.getUserAccount().authority ??
+			this.wallet.publicKey;
 		return await this.program.instruction.modifyOrder(orderId, orderParams, {
 			accounts: {
 				state: await this.getStatePublicKey(),
-				user,
+				user: userPubKey,
 				userStats: this.getUserStatsAccountPublicKey(),
-				authority: this.wallet.publicKey,
+				authority,
 			},
 			remainingAccounts,
 		});