@drift-labs/sdk 2.75.0-beta.1 → 2.75.0-beta.2

package/src/driftClient.ts

@@ -3483,7 +3483,7 @@ export class DriftClient {
 		fulfillmentConfig?:
 			| SerumV3FulfillmentConfigAccount
 			| PhoenixV1FulfillmentConfigAccount,
-		makerInfo?: MakerInfo,
+		makerInfo?: MakerInfo | MakerInfo[],
 		referrerInfo?: ReferrerInfo,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
@@ -3512,7 +3512,7 @@ export class DriftClient {
 		fulfillmentConfig?:
 			| SerumV3FulfillmentConfigAccount
 			| PhoenixV1FulfillmentConfigAccount,
-		makerInfo?: MakerInfo,
+		makerInfo?: MakerInfo | MakerInfo[],
 		referrerInfo?: ReferrerInfo,
 		fillerPublicKey?: PublicKey
 	): Promise<TransactionInstruction> {
@@ -3530,23 +3530,29 @@ export class DriftClient {
 					(order) => order.orderId === userAccount.nextOrderId - 1
 			  ).marketIndex;
 
+		makerInfo = Array.isArray(makerInfo)
+			? makerInfo
+			: makerInfo
+			? [makerInfo]
+			: [];
+
 		const userAccounts = [userAccount];
-		if (makerInfo !== undefined) {
-			userAccounts.push(makerInfo.makerUserAccount);
+		for (const maker of makerInfo) {
+			userAccounts.push(maker.makerUserAccount);
 		}
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts,
 			writableSpotMarketIndexes: [marketIndex, QUOTE_SPOT_MARKET_INDEX],
 		});
 
-		if (makerInfo) {
+		for (const maker of makerInfo) {
 			remainingAccounts.push({
-				pubkey: makerInfo.maker,
+				pubkey: maker.maker,
 				isWritable: true,
 				isSigner: false,
 			});
 			remainingAccounts.push({
-				pubkey: makerInfo.makerStats,
+				pubkey: maker.makerStats,
 				isWritable: true,
 				isSigner: false,
 			});
@@ -3566,7 +3572,6 @@ export class DriftClient {
 		}
 
 		const orderId = order.orderId;
-		const makerOrderId = makerInfo ? makerInfo.order.orderId : null;
 
 		this.addSpotFulfillmentAccounts(
 			marketIndex,
@@ -3577,7 +3582,7 @@ export class DriftClient {
 		return await this.program.instruction.fillSpotOrder(
 			orderId,
 			fulfillmentConfig ? fulfillmentConfig.fulfillmentType : null,
-			makerOrderId,
+			null,
 			{
 				accounts: {
 					state: await this.getStatePublicKey(),

package/src/idl/drift.json

@@ -8997,7 +8997,11 @@
             "name": "ExternalMarket"
           },
           {
-            "name": "Match"
+            "name": "Match",
+            "fields": [
+              "publicKey",
+              "u16"
+            ]
           }
         ]
       }

package/src/index.ts

@@ -74,6 +74,7 @@ export * from './priorityFee';
 export * from './phoenix/phoenixFulfillmentConfigMap';
 export * from './tx/fastSingleTxSender';
 export * from './tx/retryTxSender';
+export * from './tx/whileValidTxSender';
 export * from './tx/priorityFeeCalculator';
 export * from './tx/types';
 export * from './util/computeUnits';

package/src/tx/baseTxSender.ts

@@ -76,9 +76,12 @@ export abstract class BaseTxSender implements TxSender {
 			opts = this.opts;
 		}
 
-		const signedTx = preSigned
-			? tx
-			: await this.prepareTx(tx, additionalSigners, opts);
+		const signedTx = await this.prepareTx(
+			tx,
+			additionalSigners,
+			opts,
+			preSigned
+		);
 
 		if (extraConfirmationOptions?.onSignedCb) {
 			extraConfirmationOptions.onSignedCb();
@@ -90,8 +93,13 @@ export abstract class BaseTxSender implements TxSender {
 	async prepareTx(
 		tx: Transaction,
 		additionalSigners: Array<Signer>,
-		opts: ConfirmOptions
+		opts: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<Transaction> {
+		if (preSigned) {
+			return tx;
+		}
+
 		tx.feePayer = this.wallet.publicKey;
 		tx.recentBlockhash = (
 			await this.connection.getLatestBlockhash(opts.preflightCommitment)

package/src/tx/fastSingleTxSender.ts

@@ -85,24 +85,10 @@ export class FastSingleTxSender extends BaseTxSender {
 	async prepareTx(
 		tx: Transaction,
 		additionalSigners: Array<Signer>,
-		_opts: ConfirmOptions
+		_opts: ConfirmOptions,
+		preSigned?: boolean
 	): Promise<Transaction> {
-		tx.feePayer = this.wallet.publicKey;
-
-		tx.recentBlockhash =
-			this.recentBlockhash ??
-			(await this.connection.getLatestBlockhash(this.blockhashCommitment))
-				.blockhash;
-
-		additionalSigners
-			.filter((s): s is Signer => s !== undefined)
-			.forEach((kp) => {
-				tx.partialSign(kp);
-			});
-
-		const signedTx = await this.wallet.signTransaction(tx);
-
-		return signedTx;
+		return super.prepareTx(tx, additionalSigners, _opts, preSigned);
 	}
 
 	async getVersionedTransaction(

package/src/tx/whileValidTxSender.ts

@@ -0,0 +1,215 @@
+import { ExtraConfirmationOptions, TxSigAndSlot } from './types';
+import {
+	AddressLookupTableAccount,
+	ConfirmOptions,
+	Connection,
+	Signer,
+	Transaction,
+	TransactionInstruction,
+	TransactionMessage,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
+import bs58 from 'bs58';
+
+const DEFAULT_RETRY = 8000;
+
+type ResolveReference = {
+	resolve?: () => void;
+};
+
+export class WhileValidTxSender extends BaseTxSender {
+	connection: Connection;
+	wallet: IWallet;
+	opts: ConfirmOptions;
+	timeout: number;
+	retrySleep: number;
+	additionalConnections: Connection[];
+	timoutCount = 0;
+	untilValid = new Map<
+		string,
+		{ blockhash: string; lastValidBlockHeight: number }
+	>();
+
+	public constructor({
+		connection,
+		wallet,
+		opts = AnchorProvider.defaultOptions(),
+		retrySleep = DEFAULT_RETRY,
+		additionalConnections = new Array<Connection>(),
+		additionalTxSenderCallbacks = [],
+	}: {
+		connection: Connection;
+		wallet: IWallet;
+		opts?: ConfirmOptions;
+		retrySleep?: number;
+		additionalConnections?;
+		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+	}) {
+		super({
+			connection,
+			wallet,
+			opts,
+			additionalConnections,
+			additionalTxSenderCallbacks,
+		});
+		this.retrySleep = retrySleep;
+	}
+
+	async sleep(reference: ResolveReference): Promise<void> {
+		return new Promise((resolve) => {
+			reference.resolve = resolve;
+			setTimeout(resolve, this.retrySleep);
+		});
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions,
+		preSigned?: boolean
+	): Promise<Transaction> {
+		const latestBlockhash = await this.connection.getLatestBlockhash(
+			opts.preflightCommitment
+		);
+
+		// handle tx
+		let signedTx = tx;
+		if (!preSigned) {
+			tx.feePayer = this.wallet.publicKey;
+			tx.recentBlockhash = latestBlockhash.blockhash;
+
+			additionalSigners
+				.filter((s): s is Signer => s !== undefined)
+				.forEach((kp) => {
+					tx.partialSign(kp);
+				});
+
+			signedTx = await this.wallet.signTransaction(tx);
+		}
+
+		// handle subclass-specific side effects
+		const txSig = bs58.encode(tx.signatures[0]?.signature || tx.signatures[0]);
+		this.untilValid.set(txSig, latestBlockhash);
+
+		return signedTx;
+	}
+
+	async getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		_additionalSigners?: Array<Signer>,
+		_opts?: ConfirmOptions
+	): Promise<VersionedTransaction> {
+		const message = new TransactionMessage({
+			payerKey: this.wallet.publicKey,
+			recentBlockhash: '', // set blank and reset in sendVersionTransaction
+			instructions: ixs,
+		}).compileToV0Message(lookupTableAccounts);
+
+		const tx = new VersionedTransaction(message);
+
+		return tx;
+	}
+
+	async sendVersionedTransaction(
+		tx: VersionedTransaction,
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		preSigned?: boolean,
+		extraConfirmationOptions?: ExtraConfirmationOptions
+	): Promise<TxSigAndSlot> {
+		const latestBlockhash = await this.connection.getLatestBlockhash();
+		tx.message.recentBlockhash = latestBlockhash.blockhash;
+
+		let signedTx;
+		if (preSigned) {
+			signedTx = tx;
+			// @ts-ignore
+		} else if (this.wallet.payer) {
+			// @ts-ignore
+			tx.sign((additionalSigners ?? []).concat(this.wallet.payer));
+			signedTx = tx;
+		} else {
+			additionalSigners
+				?.filter((s): s is Signer => s !== undefined)
+				.forEach((kp) => {
+					tx.sign([kp]);
+				});
+			// @ts-ignore
+			signedTx = await this.wallet.signTransaction(tx);
+		}
+
+		if (extraConfirmationOptions?.onSignedCb) {
+			extraConfirmationOptions.onSignedCb();
+		}
+
+		if (opts === undefined) {
+			opts = this.opts;
+		}
+
+		const txSig = bs58.encode(signedTx.signatures[0]);
+		this.untilValid.set(txSig, latestBlockhash);
+
+		return this.sendRawTransaction(signedTx.serialize(), opts);
+	}
+
+	async sendRawTransaction(
+		rawTransaction: Buffer | Uint8Array,
+		opts: ConfirmOptions
+	): Promise<TxSigAndSlot> {
+		const startTime = this.getTimestamp();
+
+		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+		this.sendToAdditionalConnections(rawTransaction, opts);
+
+		let done = false;
+		const resolveReference: ResolveReference = {
+			resolve: undefined,
+		};
+		const stopWaiting = () => {
+			done = true;
+			if (resolveReference.resolve) {
+				resolveReference.resolve();
+			}
+		};
+
+		(async () => {
+			while (!done && this.getTimestamp() - startTime < this.timeout) {
+				await this.sleep(resolveReference);
+				if (!done) {
+					this.connection
+						.sendRawTransaction(rawTransaction, opts)
+						.catch((e) => {
+							console.error(e);
+							stopWaiting();
+						});
+					this.sendToAdditionalConnections(rawTransaction, opts);
+				}
+			}
+		})();
+
+		let slot: number;
+		try {
+			const { blockhash, lastValidBlockHeight } = this.untilValid.get(txid);
+			const result = await this.connection.confirmTransaction(
+				{
+					signature: txid,
+					lastValidBlockHeight,
+					blockhash,
+				},
+				opts.commitment
+			);
+			slot = result.context.slot;
+			// eslint-disable-next-line no-useless-catch
+		} catch (e) {
+			throw e;
+		} finally {
+			stopWaiting();
+		}
+
+		return { txSig: txid, slot };
+	}
+}