@drift-labs/sdk 2.82.0-beta.2 → 2.82.0-beta.20

package/src/tx/txParamProcessor.ts

@@ -1,10 +1,7 @@
 import {
-	AddressLookupTableAccount,
 	Connection,
 	RpcResponseAndContext,
 	SimulatedTransactionResponse,
-	TransactionInstruction,
-	TransactionVersion,
 	VersionedTransaction,
 } from '@solana/web3.js';
 import { BaseTxParams, ProcessingTxParams } from '..';
@@ -13,18 +10,14 @@ const COMPUTE_UNIT_BUFFER_FACTOR = 1.2;
 
 const TEST_SIMS_ALWAYS_FAIL = false;
 
-type TransactionProps = {
-	instructions: TransactionInstruction | TransactionInstruction[];
-	txParams?: BaseTxParams;
-	txVersion?: TransactionVersion;
-	lookupTables?: AddressLookupTableAccount[];
-	forceVersionedTransaction?: boolean;
+type TransactionBuildingProps = {
+	txParams: BaseTxParams;
 };
 
 /**
  * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
  */
-export class TransactionProcessor {
+export class TransactionParamProcessor {
 	private static async getComputeUnitsFromSim(
 		txSim: RpcResponseAndContext<SimulatedTransactionResponse>
 	) {
@@ -71,37 +64,35 @@ export class TransactionProcessor {
 	}
 
 	static async process(props: {
-		txProps: TransactionProps;
-		txBuilder: (
-			baseTransactionProps: TransactionProps
-		) => Promise<VersionedTransaction>;
+		baseTxParams: BaseTxParams;
 		processConfig: ProcessingTxParams;
 		processParams: {
 			connection: Connection;
 		};
+		txBuilder: (
+			baseTransactionProps: TransactionBuildingProps
+		) => Promise<VersionedTransaction>;
 	}): Promise<BaseTxParams> {
 		// # Exit early if no process config is provided
 		if (!props.processConfig || Object.keys(props.processConfig).length === 0) {
-			return props.txProps.txParams;
+			return props.baseTxParams;
 		}
 
 		// # Setup
 		const {
-			txProps: txProps,
 			txBuilder: txBuilder,
 			processConfig,
 			processParams: processProps,
 		} = props;
 
-		const finalTxProps = {
-			...txProps,
+		const finalTxParams: BaseTxParams = {
+			...props.baseTxParams,
 		};
 
 		// # Run Processes
 		if (processConfig.useSimulatedComputeUnits) {
 			const txToSim = await txBuilder({
-				...txProps,
-				txParams: { ...txProps.txParams, computeUnits: 1_400_000 },
+				txParams: { ...finalTxParams, computeUnits: 1_400_000 },
 			});
 
 			const txSimComputeUnitsResult = await this.getTxSimComputeUnits(
@@ -116,10 +107,7 @@ export class TransactionProcessor {
 						COMPUTE_UNIT_BUFFER_FACTOR);
 
 				// Adjust the transaction based on the simulated compute units
-				finalTxProps.txParams = {
-					...txProps.txParams,
-					computeUnits: Math.ceil(bufferedComputeUnits), // Round the compute units to a whole number
-				};
+				finalTxParams.computeUnits = Math.ceil(bufferedComputeUnits); // Round the compute units to a whole number
 			}
 		}
 
@@ -135,20 +123,20 @@ export class TransactionProcessor {
 				);
 			}
 
-			const simulatedComputeUnits = finalTxProps.txParams.computeUnits;
+			const simulatedComputeUnits = finalTxParams.computeUnits;
 
 			const computeUnitPrice = processConfig.getCUPriceFromComputeUnits(
 				simulatedComputeUnits
 			);
 
 			console.debug(
-				`🔧:: Adjusting compute unit price for simulated compute unit budget :: ${finalTxProps.txParams.computeUnitsPrice}=>${computeUnitPrice}`
+				`🔧:: Adjusting compute unit price for simulated compute unit budget :: ${finalTxParams.computeUnitsPrice}=>${computeUnitPrice}`
 			);
 
-			finalTxProps.txParams.computeUnitsPrice = computeUnitPrice;
+			finalTxParams.computeUnitsPrice = computeUnitPrice;
 		}
 
 		// # Return Final Tx Params
-		return finalTxProps.txParams;
+		return finalTxParams;
 	}
 }

package/src/tx/types.ts

@@ -1,9 +1,7 @@
 import {
-	AddressLookupTableAccount,
 	ConfirmOptions,
 	Signer,
 	Transaction,
-	TransactionInstruction,
 	TransactionSignature,
 	VersionedTransaction,
 } from '@solana/web3.js';
@@ -20,10 +18,6 @@ export type TxSigAndSlot = {
 	slot: number;
 };
 
-export type ExtraConfirmationOptions = {
-	onSignedCb: () => void;
-};
-
 export interface TxSender {
 	wallet: IWallet;
 
@@ -31,26 +25,16 @@ export interface TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions,
-		preSigned?: boolean,
-		extraConfirmationOptions?: ExtraConfirmationOptions
+		preSigned?: boolean
 	): Promise<TxSigAndSlot>;
 
 	sendVersionedTransaction(
 		tx: VersionedTransaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions,
-		preSigned?: boolean,
-		extraConfirmationOptions?: ExtraConfirmationOptions
+		preSigned?: boolean
 	): Promise<TxSigAndSlot>;
 
-	getVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		blockhash?: string
-	): Promise<VersionedTransaction>;
-
 	sendRawTransaction(
 		rawTransaction: Buffer | Uint8Array,
 		opts: ConfirmOptions
@@ -60,3 +44,15 @@ export interface TxSender {
 
 	getTimeoutCount(): number;
 }
+
+export class TxSendError extends Error {
+	constructor(
+		public message: string,
+		public code: number
+	) {
+		super(message);
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(this, TxSendError);
+		}
+	}
+}

package/src/tx/whileValidTxSender.ts

@@ -1,22 +1,19 @@
-import { ExtraConfirmationOptions, TxSigAndSlot } from './types';
+import { TxSigAndSlot } from './types';
 import {
-	AddressLookupTableAccount,
 	Commitment,
 	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';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
 
 const DEFAULT_RETRY = 2000;
-const PLACEHOLDER_BLOCKHASH = 'Fdum64WVeej6DeL85REV9NvfSxEJNPZ74DBk7A8kTrKP';
 
 type ResolveReference = {
 	resolve?: () => void;
@@ -44,6 +41,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		additionalConnections = new Array<Connection>(),
 		additionalTxSenderCallbacks = [],
 		blockhashCommitment = 'finalized',
+		txHandler,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -52,6 +50,7 @@ export class WhileValidTxSender extends BaseTxSender {
 		additionalConnections?;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		blockhashCommitment?: Commitment;
+		txHandler: TxHandler;
 	}) {
 		super({
 			connection,
@@ -59,6 +58,7 @@ export class WhileValidTxSender extends BaseTxSender {
 			opts,
 			additionalConnections,
 			additionalTxSenderCallbacks,
+			txHandler,
 		});
 		this.retrySleep = retrySleep;
 		this.blockhashCommitment = blockhashCommitment;
@@ -77,23 +77,20 @@ export class WhileValidTxSender extends BaseTxSender {
 		opts: ConfirmOptions,
 		preSigned?: boolean
 	): Promise<Transaction> {
-		const latestBlockhash = await this.connection.getLatestBlockhash(
-			this.blockhashCommitment
-		);
+		const latestBlockhash =
+			await this.txHandler.getLatestBlockhashForTransaction();
 
 		// 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);
+			signedTx = await this.txHandler.prepareTx(
+				tx,
+				additionalSigners,
+				undefined,
+				opts,
+				false,
+				latestBlockhash
+			);
 		}
 
 		// handle subclass-specific side effects
@@ -105,34 +102,14 @@ export class WhileValidTxSender extends BaseTxSender {
 		return signedTx;
 	}
 
-	async getVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
-		_additionalSigners?: Array<Signer>,
-		_opts?: ConfirmOptions,
-		blockhash?: string
-	): Promise<VersionedTransaction> {
-		const message = new TransactionMessage({
-			payerKey: this.wallet.publicKey,
-			recentBlockhash: blockhash ?? PLACEHOLDER_BLOCKHASH, // 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
+		preSigned?: boolean
 	): Promise<TxSigAndSlot> {
-		const latestBlockhash = await this.connection.getLatestBlockhash(
-			this.blockhashCommitment
-		);
+		const latestBlockhash =
+			await this.txHandler.getLatestBlockhashForTransaction();
 
 		let signedTx;
 		if (preSigned) {
@@ -150,12 +127,11 @@ export class WhileValidTxSender extends BaseTxSender {
 				.forEach((kp) => {
 					tx.sign([kp]);
 				});
-			// @ts-ignore
-			signedTx = await this.wallet.signTransaction(tx);
-		}
-
-		if (extraConfirmationOptions?.onSignedCb) {
-			extraConfirmationOptions.onSignedCb();
+			signedTx = await this.txHandler.signVersionedTx(
+				tx,
+				additionalSigners,
+				latestBlockhash
+			);
 		}
 
 		if (opts === undefined) {

package/src/types.ts

@@ -33,12 +33,21 @@ export enum PerpOperation {
 	FILL = 4,
 	SETTLE_PNL = 8,
 	SETTLE_PNL_WITH_POSITION = 16,
+	LIQUIDATION = 32,
 }
 
 export enum SpotOperation {
 	UPDATE_CUMULATIVE_INTEREST = 1,
 	FILL = 2,
 	WITHDRAW = 4,
+	LIQUIDATION = 8,
+}
+
+export enum InsuranceFundOperation {
+	INIT = 1,
+	ADD = 2,
+	REQUEST_REMOVE = 4,
+	REMOVE = 8,
 }
 
 export enum UserStatus {
@@ -706,6 +715,8 @@ export type SpotMarketAccount = {
 	ordersEnabled: boolean;
 
 	pausedOperations: number;
+
+	ifPausedOperations: number;
 };
 
 export type PoolBalance = {
@@ -1002,10 +1013,12 @@ export type ReferrerInfo = {
 	referrerStats: PublicKey;
 };
 
-export type BaseTxParams = {
+type ExactType<T> = Pick<T, keyof T>;
+
+export type BaseTxParams = ExactType<{
 	computeUnits?: number;
 	computeUnitsPrice?: number;
-};
+}>;
 
 export type ProcessingTxParams = {
 	useSimulatedComputeUnits?: boolean;
@@ -1171,3 +1184,14 @@ export type HealthComponent = {
 	weight: BN;
 	weightedValue: BN;
 };
+
+export interface DriftClientMetricsEvents {
+	txSigned: SignedTxData[];
+}
+
+export type SignedTxData = {
+	txSig: string;
+	signedTx: Transaction | VersionedTransaction;
+	lastValidBlockHeight?: number;
+	blockHash: string;
+};

package/src/user.ts

@@ -118,7 +118,10 @@ export class User {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
 				config.userAccountPublicKey,
-				config.accountSubscription?.resubTimeoutMs,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				},
 				config.accountSubscription?.commitment
 			);
 		}
@@ -3162,35 +3165,6 @@ export class User {
 		return state.spotFeeStructure.feeTiers[feeTierIndex];
 	}
 
-	/**
-	 * Calculates taker / maker fee (as a percentage, e.g. .001 = 10 basis points) for particular marketType
-	 * @param marketType
-	 * @param positionMarketIndex
-	 * @returns : {takerFee: number, makerFee: number} Precision None
-	 */
-	public getMarketFees(marketType: MarketType, marketIndex?: number) {
-		const feeTier = this.getUserFeeTier(marketType);
-		let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
-		let makerFee =
-			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
-
-		if (marketIndex !== undefined) {
-			let marketAccount = null;
-			if (isVariant(marketType, 'perp')) {
-				marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
-			} else {
-				marketAccount = this.driftClient.getSpotMarketAccount(marketIndex);
-			}
-			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
-			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
-		}
-
-		return {
-			takerFee,
-			makerFee,
-		};
-	}
-
 	/**
 	 * Calculates how much perp fee will be taken for a given sized trade
 	 * @param quoteAmount
@@ -3198,9 +3172,10 @@ export class User {
 	 */
 	public calculateFeeForQuoteAmount(quoteAmount: BN, marketIndex?: number): BN {
 		if (marketIndex !== undefined) {
-			const takerFeeMultiplier = this.getMarketFees(
+			const takerFeeMultiplier = this.driftClient.getMarketFees(
 				MarketType.PERP,
-				marketIndex
+				marketIndex,
+				this
 			).takerFee;
 			const feeAmountNum =
 				BigNum.from(quoteAmount, QUOTE_PRECISION_EXP).toNum() *

package/src/userConfig.ts

@@ -13,6 +13,7 @@ export type UserSubscriptionConfig =
 	| {
 			type: 'websocket';
 			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
 			commitment?: Commitment;
 	  }
 	| {

package/src/userMap/WebsocketSubscription.ts

@@ -3,12 +3,13 @@ import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
 import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 import { UserAccount } from '../types';
 import { Commitment, Context, PublicKey } from '@solana/web3.js';
+import { ResubOpts } from '../accounts/types';
 
 export class WebsocketSubscription {
 	private userMap: UserMap;
 	private commitment: Commitment;
 	private skipInitialLoad: boolean;
-	private resubTimeoutMs?: number;
+	private resubOpts?: ResubOpts;
 	private includeIdle?: boolean;
 	private decodeFn: (name: string, data: Buffer) => UserAccount;
 
@@ -18,21 +19,21 @@ export class WebsocketSubscription {
 		userMap,
 		commitment,
 		skipInitialLoad = false,
-		resubTimeoutMs,
+		resubOpts,
 		includeIdle = false,
 		decodeFn,
 	}: {
 		userMap: UserMap;
 		commitment: Commitment;
 		skipInitialLoad?: boolean;
-		resubTimeoutMs?: number;
+		resubOpts?: ResubOpts;
 		includeIdle?: boolean;
 		decodeFn: (name: string, data: Buffer) => UserAccount;
 	}) {
 		this.userMap = userMap;
 		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
-		this.resubTimeoutMs = resubTimeoutMs;
+		this.resubOpts = resubOpts;
 		this.includeIdle = includeIdle || false;
 		this.decodeFn = decodeFn;
 	}
@@ -52,7 +53,7 @@ export class WebsocketSubscription {
 					filters,
 					commitment: this.commitment,
 				},
-				this.resubTimeoutMs
+				this.resubOpts
 			);
 		}
 

package/src/userMap/userMap.ts

@@ -124,7 +124,10 @@ export class UserMap implements UserMapInterface {
 			this.subscription = new WebsocketSubscription({
 				userMap: this,
 				commitment: this.commitment,
-				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+				resubOpts: {
+					resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
+					logResubMessages: config.subscriptionConfig.logResubMessages,
+				},
 				skipInitialLoad: config.skipInitialLoad,
 				decodeFn,
 			});

package/src/userMap/userMapConfig.ts

@@ -20,6 +20,7 @@ export type UserMapConfig = {
 		| {
 				type: 'websocket';
 				resubTimeoutMs?: number;
+				logResubMessages?: boolean;
 				commitment?: Commitment;
 		  };
 

package/src/userStats.ts

@@ -29,7 +29,10 @@ export class UserStats {
 			this.accountSubscriber = new WebSocketUserStatsAccountSubscriber(
 				config.driftClient.program,
 				config.userStatsAccountPublicKey,
-				config.accountSubscription.resubTimeoutMs,
+				{
+					resubTimeoutMs: config.accountSubscription?.resubTimeoutMs,
+					logResubMessages: config.accountSubscription?.logResubMessages,
+				},
 				config.accountSubscription.commitment
 			);
 		} else {

package/src/userStatsConfig.ts

@@ -12,6 +12,7 @@ export type UserStatsSubscriptionConfig =
 	| {
 			type: 'websocket';
 			resubTimeoutMs?: number;
+			logResubMessages?: boolean;
 			commitment?: Commitment;
 	  }
 	| {

package/src/util/chainClock.ts

@@ -0,0 +1,41 @@
+import { Commitment } from '@solana/web3.js';
+
+export type ChainClockProgress = {
+	blockHeight?: number;
+	slot?: number;
+	ts?: number;
+};
+
+export type ChainClockUpdateProps = {
+	commitment: Commitment;
+} & ChainClockProgress;
+
+export type ChainClockState = Map<Commitment, ChainClockProgress>;
+
+export type ChainClickInitialisationProps = ChainClockUpdateProps[];
+
+export class ChainClock {
+	private _state: ChainClockState;
+
+	constructor(props: ChainClickInitialisationProps) {
+		this._state = new Map<Commitment, ChainClockUpdateProps>();
+		props.forEach((prop) => {
+			this._state.set(prop.commitment, prop);
+		});
+	}
+
+	update(props: ChainClockUpdateProps): void {
+		const state = this._state.get(props.commitment);
+		if (state) {
+			if (props.blockHeight) state.blockHeight = props.blockHeight;
+			if (props.slot) state.slot = props.slot;
+			if (props.ts) state.ts = props.ts;
+		} else {
+			this._state.set(props.commitment, props);
+		}
+	}
+
+	public getState(commitment: Commitment): ChainClockProgress {
+		return this._state.get(commitment);
+	}
+}

package/tests/dlob/helpers.ts

@@ -350,6 +350,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 			lastIndexPriceTwapTs: new BN(0),
 		},
 		pausedOperations: 0,
+		ifPausedOperations: 0,
 	},
 	{
 		status: MarketStatus.ACTIVE,
@@ -432,6 +433,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 			lastIndexPriceTwapTs: new BN(0),
 		},
 		pausedOperations: 0,
+		ifPausedOperations: 0,
 	},
 	{
 		status: MarketStatus.ACTIVE,
@@ -514,6 +516,7 @@ export const mockSpotMarkets: Array<SpotMarketAccount> = [
 			lastIndexPriceTwapTs: new BN(0),
 		},
 		pausedOperations: 0,
+		ifPausedOperations: 0,
 	},
 ];
 

package/lib/tx/utils.d.ts

@@ -1,6 +0,0 @@
-import { Wallet } from '@coral-xyz/anchor';
-import { Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
-export declare function wrapInTx(instruction: TransactionInstruction, computeUnits?: number, computeUnitsPrice?: number): Transaction;
-export declare function getSignedTransactionMap(wallet: Wallet, txsToSign: (Transaction | VersionedTransaction | undefined)[], keys: string[]): Promise<{
-    [key: string]: Transaction | VersionedTransaction | undefined;
-}>;

package/lib/tx/utils.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSignedTransactionMap = exports.wrapInTx = void 0;
-const web3_js_1 = require("@solana/web3.js");
-const COMPUTE_UNITS_DEFAULT = 200000;
-function wrapInTx(instruction, computeUnits = 600000, computeUnitsPrice = 0) {
-    const tx = new web3_js_1.Transaction();
-    if (computeUnits != COMPUTE_UNITS_DEFAULT) {
-        tx.add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
-            units: computeUnits,
-        }));
-    }
-    if (computeUnitsPrice != 0) {
-        tx.add(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
-            microLamports: computeUnitsPrice,
-        }));
-    }
-    return tx.add(instruction);
-}
-exports.wrapInTx = wrapInTx;
-/* Helper function for signing multiple transactions where some may be undefined and mapping the output */
-async function getSignedTransactionMap(wallet, txsToSign, keys) {
-    const signedTxMap = {};
-    const keysWithTx = [];
-    txsToSign.forEach((tx, index) => {
-        if (tx == undefined) {
-            signedTxMap[keys[index]] = undefined;
-        }
-        else {
-            keysWithTx.push(keys[index]);
-        }
-    });
-    const signedTxs = await wallet.signAllTransactions(txsToSign.filter((tx) => tx !== undefined));
-    signedTxs.forEach((signedTx, index) => {
-        signedTxMap[keysWithTx[index]] = signedTx;
-    });
-    return signedTxMap;
-}
-exports.getSignedTransactionMap = getSignedTransactionMap;