@drift-labs/sdk 2.85.0-beta.0 → 2.85.0-beta.10

package/src/bankrun/bankrunConnection.ts

@@ -0,0 +1,466 @@
+import {
+	TransactionConfirmationStatus,
+	AccountInfo,
+	Keypair,
+	PublicKey,
+	Transaction,
+	RpcResponseAndContext,
+	Commitment,
+	TransactionSignature,
+	SignatureStatusConfig,
+	SignatureStatus,
+	GetVersionedTransactionConfig,
+	GetTransactionConfig,
+	VersionedTransaction,
+	SimulateTransactionConfig,
+	SimulatedTransactionResponse,
+	TransactionReturnData,
+	TransactionError,
+	SignatureResultCallback,
+	ClientSubscriptionId,
+	Connection as SolanaConnection,
+	SystemProgram,
+	Blockhash,
+	LogsFilter,
+	LogsCallback,
+	AccountChangeCallback,
+	LAMPORTS_PER_SOL,
+} from '@solana/web3.js';
+import {
+	ProgramTestContext,
+	BanksClient,
+	BanksTransactionResultWithMeta,
+	Clock,
+} from 'solana-bankrun';
+import { BankrunProvider } from 'anchor-bankrun';
+import bs58 from 'bs58';
+import { BN, Wallet } from '@coral-xyz/anchor';
+import { Account, TOKEN_PROGRAM_ID, unpackAccount } from '@solana/spl-token';
+
+export type Connection = SolanaConnection | BankrunConnection;
+
+type BankrunTransactionMetaNormalized = {
+	logMessages: string[];
+	err: TransactionError;
+};
+
+type BankrunTransactionRespose = {
+	slot: number;
+	meta: BankrunTransactionMetaNormalized;
+};
+
+export class BankrunContextWrapper {
+	public readonly connection: BankrunConnection;
+	public readonly context: ProgramTestContext;
+	public readonly provider: BankrunProvider;
+	public readonly commitment: Commitment = 'confirmed';
+
+	constructor(context: ProgramTestContext) {
+		this.context = context;
+		this.provider = new BankrunProvider(context);
+		this.connection = new BankrunConnection(
+			this.context.banksClient,
+			this.context
+		);
+	}
+
+	async sendTransaction(
+		tx: Transaction,
+		additionalSigners?: Keypair[]
+	): Promise<TransactionSignature> {
+		tx.recentBlockhash = (await this.getLatestBlockhash()).toString();
+		tx.feePayer = this.context.payer.publicKey;
+		if (!additionalSigners) {
+			additionalSigners = [];
+		}
+		tx.sign(this.context.payer, ...additionalSigners);
+		return await this.connection.sendTransaction(tx);
+	}
+
+	async getMinimumBalanceForRentExemption(_: number): Promise<number> {
+		return 10 * LAMPORTS_PER_SOL;
+	}
+
+	async fundKeypair(
+		keypair: Keypair | Wallet,
+		lamports: number | bigint
+	): Promise<TransactionSignature> {
+		const ixs = [
+			SystemProgram.transfer({
+				fromPubkey: this.context.payer.publicKey,
+				toPubkey: keypair.publicKey,
+				lamports,
+			}),
+		];
+		const tx = new Transaction().add(...ixs);
+		return await this.sendTransaction(tx);
+	}
+
+	async getLatestBlockhash(): Promise<Blockhash> {
+		const blockhash = await this.connection.getLatestBlockhash('finalized');
+
+		return blockhash.blockhash;
+	}
+
+	printTxLogs(signature: string): void {
+		this.connection.printTxLogs(signature);
+	}
+
+	async moveTimeForward(increment: number): Promise<void> {
+		const currentClock = await this.context.banksClient.getClock();
+		const newUnixTimestamp = currentClock.unixTimestamp + BigInt(increment);
+		const newClock = new Clock(
+			currentClock.slot,
+			currentClock.epochStartTimestamp,
+			currentClock.epoch,
+			currentClock.leaderScheduleEpoch,
+			newUnixTimestamp
+		);
+		await this.context.setClock(newClock);
+	}
+}
+
+export class BankrunConnection {
+	private readonly _banksClient: BanksClient;
+	private readonly context: ProgramTestContext;
+	private transactionToMeta: Map<
+		TransactionSignature,
+		BanksTransactionResultWithMeta
+	> = new Map();
+	private clock: Clock;
+
+	private nextClientSubscriptionId = 0;
+	private onLogCallbacks = new Map<number, LogsCallback>();
+	private onAccountChangeCallbacks = new Map<
+		number,
+		[PublicKey, AccountChangeCallback]
+	>();
+
+	constructor(banksClient: BanksClient, context: ProgramTestContext) {
+		this._banksClient = banksClient;
+		this.context = context;
+	}
+
+	getSlot(): Promise<bigint> {
+		return this._banksClient.getSlot();
+	}
+
+	toConnection(): SolanaConnection {
+		return this as unknown as SolanaConnection;
+	}
+
+	async getTokenAccount(publicKey: PublicKey): Promise<Account> {
+		const info = await this.getAccountInfo(publicKey);
+		return unpackAccount(publicKey, info, TOKEN_PROGRAM_ID);
+	}
+
+	async getMultipleAccountsInfo(
+		publicKeys: PublicKey[],
+		_commitmentOrConfig?: Commitment
+	): Promise<AccountInfo<Buffer>[]> {
+		const accountInfos = [];
+
+		for (const publicKey of publicKeys) {
+			const accountInfo = await this.getAccountInfo(publicKey);
+			accountInfos.push(accountInfo);
+		}
+
+		return accountInfos;
+	}
+
+	async getAccountInfo(
+		publicKey: PublicKey
+	): Promise<null | AccountInfo<Buffer>> {
+		const parsedAccountInfo = await this.getParsedAccountInfo(publicKey);
+		return parsedAccountInfo ? parsedAccountInfo.value : null;
+	}
+
+	async getAccountInfoAndContext(
+		publicKey: PublicKey,
+		_commitment?: Commitment
+	): Promise<RpcResponseAndContext<null | AccountInfo<Buffer>>> {
+		return await this.getParsedAccountInfo(publicKey);
+	}
+	async sendRawTransaction(
+		rawTransaction: Buffer | Uint8Array | Array<number>,
+		// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+		_options?: any
+	): Promise<TransactionSignature> {
+		const tx = Transaction.from(rawTransaction);
+		const signature = await this.sendTransaction(tx);
+		return signature;
+	}
+
+	async sendTransaction(tx: Transaction): Promise<TransactionSignature> {
+		const banksTransactionMeta = await this._banksClient.tryProcessTransaction(
+			tx
+		);
+		if (banksTransactionMeta.result) {
+			throw new Error(banksTransactionMeta.result);
+		}
+		const signature = bs58.encode(tx.signatures[0].signature);
+		this.transactionToMeta.set(signature, banksTransactionMeta);
+		let finalizedCount = 0;
+		while (finalizedCount < 10) {
+			const signatureStatus = (await this.getSignatureStatus(signature)).value
+				.confirmationStatus;
+			if (signatureStatus.toString() == '"finalized"') {
+				finalizedCount += 1;
+			}
+		}
+
+		// update the clock slot/timestamp
+		// sometimes race condition causes failures so we retry
+		try {
+			await this.updateSlotAndClock();
+		} catch (e) {
+			await this.updateSlotAndClock();
+		}
+
+		if (this.onLogCallbacks.size > 0) {
+			const transaction = await this.getTransaction(signature);
+
+			const context = { slot: transaction.slot };
+			const logs = {
+				logs: transaction.meta.logMessages,
+				err: transaction.meta.err,
+				signature,
+			};
+			for (const logCallback of this.onLogCallbacks.values()) {
+				logCallback(logs, context);
+			}
+		}
+
+		for (const [
+			publicKey,
+			callback,
+		] of this.onAccountChangeCallbacks.values()) {
+			const accountInfo = await this.getParsedAccountInfo(publicKey);
+			callback(accountInfo.value, accountInfo.context);
+		}
+
+		return signature;
+	}
+
+	private async updateSlotAndClock() {
+		const currentSlot = await this.getSlot();
+		const nextSlot = currentSlot + BigInt(1);
+		this.context.warpToSlot(nextSlot);
+		const currentClock = await this._banksClient.getClock();
+		const newClock = new Clock(
+			nextSlot,
+			currentClock.epochStartTimestamp,
+			currentClock.epoch,
+			currentClock.leaderScheduleEpoch,
+			currentClock.unixTimestamp + BigInt(1)
+		);
+		this.context.setClock(newClock);
+		this.clock = newClock;
+	}
+
+	getTime(): number {
+		return Number(this.clock.unixTimestamp);
+	}
+
+	async getParsedAccountInfo(
+		publicKey: PublicKey
+	): Promise<RpcResponseAndContext<AccountInfo<Buffer>>> {
+		const accountInfoBytes = await this._banksClient.getAccount(publicKey);
+		if (accountInfoBytes === null) {
+			return {
+				context: { slot: Number(await this._banksClient.getSlot()) },
+				value: null,
+			};
+		}
+		accountInfoBytes.data = Buffer.from(accountInfoBytes.data);
+		const accountInfoBuffer = accountInfoBytes as AccountInfo<Buffer>;
+		return {
+			context: { slot: Number(await this._banksClient.getSlot()) },
+			value: accountInfoBuffer,
+		};
+	}
+
+	async getLatestBlockhash(commitment?: Commitment): Promise<
+		Readonly<{
+			blockhash: string;
+			lastValidBlockHeight: number;
+		}>
+	> {
+		const blockhashAndBlockheight = await this._banksClient.getLatestBlockhash(
+			commitment
+		);
+		return {
+			blockhash: blockhashAndBlockheight[0],
+			lastValidBlockHeight: Number(blockhashAndBlockheight[1]),
+		};
+	}
+
+	async getSignatureStatus(
+		signature: string,
+		_config?: SignatureStatusConfig
+	): Promise<RpcResponseAndContext<null | SignatureStatus>> {
+		const transactionStatus = await this._banksClient.getTransactionStatus(
+			signature
+		);
+		if (transactionStatus === null) {
+			return {
+				context: { slot: Number(await this._banksClient.getSlot()) },
+				value: null,
+			};
+		}
+		return {
+			context: { slot: Number(await this._banksClient.getSlot()) },
+			value: {
+				slot: Number(transactionStatus.slot),
+				confirmations: Number(transactionStatus.confirmations),
+				err: transactionStatus.err,
+				confirmationStatus:
+					transactionStatus.confirmationStatus as TransactionConfirmationStatus,
+			},
+		};
+	}
+
+	/**
+	 * There's really no direct equivalent to getTransaction exposed by SolanaProgramTest, so we do the best that we can here - it's a little hacky.
+	 */
+	async getTransaction(
+		signature: string,
+		_rawConfig?: GetTransactionConfig | GetVersionedTransactionConfig
+	): Promise<BankrunTransactionRespose | null> {
+		const txMeta = this.transactionToMeta.get(
+			signature as TransactionSignature
+		);
+		if (txMeta === undefined) {
+			return null;
+		}
+		const transactionStatus = await this._banksClient.getTransactionStatus(
+			signature
+		);
+		const meta: BankrunTransactionMetaNormalized = {
+			logMessages: txMeta.meta.logMessages,
+			err: txMeta.result,
+		};
+		return {
+			slot: Number(transactionStatus.slot),
+			meta,
+		};
+	}
+
+	findComputeUnitConsumption(signature: string): bigint {
+		const txMeta = this.transactionToMeta.get(
+			signature as TransactionSignature
+		);
+		if (txMeta === undefined) {
+			throw new Error('Transaction not found');
+		}
+		return txMeta.meta.computeUnitsConsumed;
+	}
+
+	printTxLogs(signature: string): void {
+		const txMeta = this.transactionToMeta.get(
+			signature as TransactionSignature
+		);
+		if (txMeta === undefined) {
+			throw new Error('Transaction not found');
+		}
+		console.log(txMeta.meta.logMessages);
+	}
+
+	async simulateTransaction(
+		transaction: Transaction | VersionedTransaction,
+		_config?: SimulateTransactionConfig
+	): Promise<RpcResponseAndContext<SimulatedTransactionResponse>> {
+		const simulationResult = await this._banksClient.simulateTransaction(
+			transaction
+		);
+		const returnDataProgramId =
+			simulationResult.meta?.returnData?.programId.toBase58();
+		const returnDataNormalized = Buffer.from(
+			simulationResult.meta?.returnData?.data
+		).toString('base64');
+		const returnData: TransactionReturnData = {
+			programId: returnDataProgramId,
+			data: [returnDataNormalized, 'base64'],
+		};
+		return {
+			context: { slot: Number(await this._banksClient.getSlot()) },
+			value: {
+				err: simulationResult.result,
+				logs: simulationResult.meta.logMessages,
+				accounts: undefined,
+				unitsConsumed: Number(simulationResult.meta.computeUnitsConsumed),
+				returnData,
+			},
+		};
+	}
+
+	onSignature(
+		signature: string,
+		callback: SignatureResultCallback,
+		commitment?: Commitment
+	): ClientSubscriptionId {
+		const txMeta = this.transactionToMeta.get(
+			signature as TransactionSignature
+		);
+		this._banksClient.getSlot(commitment).then((slot) => {
+			if (txMeta) {
+				callback({ err: txMeta.result }, { slot: Number(slot) });
+			}
+		});
+		return 0;
+	}
+
+	async removeSignatureListener(_clientSubscriptionId: number): Promise<void> {
+		// Nothing actually has to happen here! Pretty cool, huh?
+		// This function signature only exists to match the web3js interface
+	}
+
+	onLogs(
+		filter: LogsFilter,
+		callback: LogsCallback,
+		_commitment?: Commitment
+	): ClientSubscriptionId {
+		const subscriptId = this.nextClientSubscriptionId;
+
+		this.onLogCallbacks.set(subscriptId, callback);
+
+		this.nextClientSubscriptionId += 1;
+
+		return subscriptId;
+	}
+
+	async removeOnLogsListener(
+		clientSubscriptionId: ClientSubscriptionId
+	): Promise<void> {
+		this.onLogCallbacks.delete(clientSubscriptionId);
+	}
+
+	onAccountChange(
+		publicKey: PublicKey,
+		callback: AccountChangeCallback,
+		// @ts-ignore
+		_commitment?: Commitment
+	): ClientSubscriptionId {
+		const subscriptId = this.nextClientSubscriptionId;
+
+		this.onAccountChangeCallbacks.set(subscriptId, [publicKey, callback]);
+
+		this.nextClientSubscriptionId += 1;
+
+		return subscriptId;
+	}
+
+	async removeAccountChangeListener(
+		clientSubscriptionId: ClientSubscriptionId
+	): Promise<void> {
+		this.onAccountChangeCallbacks.delete(clientSubscriptionId);
+	}
+
+	async getMinimumBalanceForRentExemption(_: number): Promise<number> {
+		return 10 * LAMPORTS_PER_SOL;
+	}
+}
+
+export function asBN(value: number | bigint): BN {
+	return new BN(Number(value));
+}

package/src/blockhashSubscriber/BlockhashSubscriber.ts

@@ -75,27 +75,32 @@ export class BlockhashSubscriber {
 	}
 
 	async updateBlockhash() {
-		const [resp, lastConfirmedBlockHeight] = await Promise.all([
-			this.connection.getLatestBlockhashAndContext({
-				commitment: this.commitment,
-			}),
-			this.connection.getBlockHeight({ commitment: this.commitment }),
-		]);
-		this.latestBlockHeight = lastConfirmedBlockHeight;
-		this.latestBlockHeightContext = resp.context;
-
-		// avoid caching duplicate blockhashes
-		if (this.blockhashes.length > 0) {
-			if (
-				resp.value.blockhash ===
-				this.blockhashes[this.blockhashes.length - 1].blockhash
-			) {
-				return;
+		try {
+			const [resp, lastConfirmedBlockHeight] = await Promise.all([
+				this.connection.getLatestBlockhashAndContext({
+					commitment: this.commitment,
+				}),
+				this.connection.getBlockHeight({ commitment: this.commitment }),
+			]);
+			this.latestBlockHeight = lastConfirmedBlockHeight;
+			this.latestBlockHeightContext = resp.context;
+
+			// avoid caching duplicate blockhashes
+			if (this.blockhashes.length > 0) {
+				if (
+					resp.value.blockhash ===
+					this.blockhashes[this.blockhashes.length - 1].blockhash
+				) {
+					return;
+				}
 			}
-		}
 
-		this.blockhashes.push(resp.value);
-		this.pruneBlockhashes();
+			this.blockhashes.push(resp.value);
+		} catch (e) {
+			console.error('Error updating blockhash:\n', e);
+		} finally {
+			this.pruneBlockhashes();
+		}
 	}
 
 	async subscribe() {

package/src/constants/perpMarkets.ts

@@ -597,6 +597,16 @@ export const MainnetPerpMarkets: PerpMarketConfig[] = [
 		launchTs: 1718021389000,
 		oracleSource: OracleSource.SWITCHBOARD,
 	},
+	{
+		fullName: 'ZEX',
+		category: ['DEX', 'Solana'],
+		symbol: 'ZEX-PERP',
+		baseAssetSymbol: 'ZEX',
+		marketIndex: 33,
+		oracle: new PublicKey('4gdbqxkMrF1bYVeEJKRmTqCCvJjRCZrRhxvriGY6SwLj'),
+		launchTs: 1719415157000,
+		oracleSource: OracleSource.SWITCHBOARD,
+	},
 ];
 
 export const PerpMarkets: { [key in DriftEnv]: PerpMarketConfig[] } = {

package/src/constants/spotMarkets.ts

@@ -283,6 +283,16 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 		precisionExp: SIX,
 		launchTs: 1718811089000,
 	},
+	{
+		symbol: 'JLP',
+		marketIndex: 19,
+		oracle: new PublicKey('pmHEXBam7kbmCCg5ED5V7RNMN8e34sKu338KeuFAGof'),
+		oracleSource: OracleSource.SWITCHBOARD,
+		mint: new PublicKey('27G8MtK7VtTcCHkpASjSDdkWWYfoqT6ggEuKidVJidD4'),
+		precision: new BN(10).pow(SIX),
+		precisionExp: SIX,
+		launchTs: 1719415157000,
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/driftClient.ts

@@ -1527,6 +1527,7 @@ export class DriftClient {
 
 		if (params.useMarketLastSlotCache) {
 			const lastUserSlot = this.getUserAccountAndSlot()?.slot;
+
 			for (const [
 				marketIndex,
 				slot,
@@ -2769,7 +2770,7 @@ export class DriftClient {
 	}
 
 	public async sendSignedTx(
-		tx: Transaction,
+		tx: Transaction | VersionedTransaction,
 		opts?: ConfirmOptions
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
@@ -4117,6 +4118,10 @@ export class DriftClient {
 		const outMarket = this.getSpotMarketAccount(outMarketIndex);
 		const inMarket = this.getSpotMarketAccount(inMarketIndex);
 
+		const isExactOut = swapMode === 'ExactOut' || quote.swapMode === 'ExactOut';
+		const amountIn = new BN(quote.inAmount);
+		const exactOutBufferedAmountIn = amountIn.muln(1001).divn(1000); // Add 10bp buffer
+
 		if (!quote) {
 			const fetchedQuote = await jupiterClient.getQuote({
 				inputMint: inMarket.mint,
@@ -4197,7 +4202,7 @@ export class DriftClient {
 		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
 			outMarketIndex,
 			inMarketIndex,
-			amountIn: new BN(quote.inAmount),
+			amountIn: isExactOut ? exactOutBufferedAmountIn : amountIn,
 			inTokenAccount: inAssociatedTokenAccount,
 			outTokenAccount: outAssociatedTokenAccount,
 			reduceOnly,
@@ -4663,7 +4668,8 @@ export class DriftClient {
 					await TransactionParamProcessor.getTxSimComputeUnits(
 						placeAndTakeTxToSim,
 						this.connection,
-						txParams.computeUnitsBufferMultiplier ?? 1.2
+						txParams.computeUnitsBufferMultiplier ?? 1.2,
+						txParams.lowerBoundCu
 					);
 
 				if (shouldExitIfSimulationFails && !simulationResult.success) {
@@ -4783,6 +4789,10 @@ export class DriftClient {
 				exitEarlyIfSimFails
 			);
 
+		if (!txsToSign) {
+			return null;
+		}
+
 		const signedTxs = (
 			await this.txHandler.getSignedTransactionMap(
 				txsToSign,
@@ -6306,7 +6316,8 @@ export class DriftClient {
 	public async getAddInsuranceFundStakeIx(
 		marketIndex: number,
 		amount: BN,
-		collateralAccountPublicKey: PublicKey
+		collateralAccountPublicKey: PublicKey,
+		fromSubAccount?: boolean
 	): Promise<TransactionInstruction> {
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
 		const ifStakeAccountPublicKey = getInsuranceFundStakeAccountPublicKey(
@@ -6316,8 +6327,8 @@ export class DriftClient {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
-			useMarketLastSlotCache: true,
+			userAccounts: fromSubAccount ? [this.getUserAccount()] : [],
+			useMarketLastSlotCache: fromSubAccount ? true : false,
 			writableSpotMarketIndexes: [marketIndex],
 		});
 
@@ -6416,7 +6427,8 @@ export class DriftClient {
 		const addFundsIx = await this.getAddInsuranceFundStakeIx(
 			marketIndex,
 			amount,
-			tokenAccount
+			tokenAccount,
+			fromSubaccount
 		);
 
 		addIfStakeIxs.push(addFundsIx);
@@ -6456,8 +6468,7 @@ export class DriftClient {
 		);
 
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: [this.getUserAccount()],
-			useMarketLastSlotCache: true,
+			userAccounts: [],
 			writableSpotMarketIndexes: [marketIndex],
 		});
 
@@ -6566,13 +6577,8 @@ export class DriftClient {
 			}
 		}
 
-		const userAccountExists =
-			!!this.getUser()?.accountSubscriber?.isSubscribed &&
-			(await this.checkIfAccountExists(this.getUser().userAccountPublicKey));
-
 		const remainingAccounts = this.getRemainingAccounts({
-			userAccounts: userAccountExists ? [this.getUserAccount()] : [],
-			useMarketLastSlotCache: false,
+			userAccounts: [],
 			writableSpotMarketIndexes: [marketIndex],
 		});
 

package/src/events/eventSubscriber.ts

@@ -45,6 +45,7 @@ export class EventSubscriber {
 
 		if (this.options.logProviderConfig.type === 'websocket') {
 			this.logProvider = new WebSocketLogProvider(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				this.options.commitment,
@@ -52,6 +53,7 @@ export class EventSubscriber {
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				options.commitment,
@@ -101,6 +103,7 @@ export class EventSubscriber {
 									this.logProvider.eventEmitter.removeAllListeners('reconnect');
 									this.unsubscribe().then(() => {
 										this.logProvider = new PollingLogProvider(
+											// @ts-ignore
 											this.connection,
 											this.address,
 											this.options.commitment,
@@ -148,6 +151,7 @@ export class EventSubscriber {
 		}
 
 		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+
 		for (const wrappedEvent of wrappedEvents) {
 			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
 		}
@@ -188,6 +192,7 @@ export class EventSubscriber {
 		const untilTx: TransactionSignature = this.options.untilTx;
 		while (txFetched < this.options.maxTx) {
 			const response = await fetchLogs(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				this.options.commitment === 'finalized' ? 'finalized' : 'confirmed',