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

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -10,16 +10,20 @@ export class PriorityFeeSubscriber {
 	customStrategy?: PriorityFeeStrategy;
 	averageStrategy = new AverageOverSlotsStrategy();
 	maxStrategy = new MaxOverSlotsStrategy();
+	lookbackDistance: number;
 
 	intervalId?: ReturnType<typeof setTimeout>;
 
 	latestPriorityFee = 0;
-	lastStrategyResult = 0;
 	lastCustomStrategyResult = 0;
 	lastAvgStrategyResult = 0;
 	lastMaxStrategyResult = 0;
 	lastSlotSeen = 0;
 
+	/**
+	 * @param props
+	 * customStrategy : strategy to return the priority fee to use based on recent samples. defaults to AVERAGE.
+	 */
 	public constructor({
 		connection,
 		frequencyMs,
@@ -36,28 +40,12 @@ export class PriorityFeeSubscriber {
 		this.connection = connection;
 		this.frequencyMs = frequencyMs;
 		this.addresses = addresses;
-		if (slotsToCheck) {
-			this.averageStrategy = new AverageOverSlotsStrategy(slotsToCheck);
-			this.maxStrategy = new MaxOverSlotsStrategy(slotsToCheck);
-		}
-		if (customStrategy) {
+		if (!customStrategy) {
+			this.customStrategy = new AverageOverSlotsStrategy();
+		} else {
 			this.customStrategy = customStrategy;
 		}
-	}
-
-	public get avgPriorityFee(): number {
-		return Math.floor(this.lastAvgStrategyResult);
-	}
-
-	public get maxPriorityFee(): number {
-		return Math.floor(this.lastMaxStrategyResult);
-	}
-
-	public get customPriorityFee(): number {
-		if (!this.customStrategy) {
-			console.error('Custom strategy not set');
-		}
-		return Math.floor(this.lastCustomStrategyResult);
+		this.lookbackDistance = slotsToCheck;
 	}
 
 	public async subscribe(): Promise<void> {
@@ -75,21 +63,29 @@ export class PriorityFeeSubscriber {
 			[this.addresses]
 		);
 
-		// getRecentPrioritizationFees returns results unsorted
 		const results: { slot: number; prioritizationFee: number }[] =
 			rpcJSONResponse?.result;
+
 		if (!results.length) return;
-		const descResults = results.sort((a, b) => b.slot - a.slot);
 
+		// # Sort and filter results based on the slot lookback setting
+		const descResults = results.sort((a, b) => b.slot - a.slot);
 		const mostRecentResult = descResults[0];
+		const cutoffSlot = mostRecentResult.slot - this.lookbackDistance;
+
+		const resultsToUse = descResults.filter(
+			(result) => result.slot >= cutoffSlot
+		);
+
+		// # Handle results
 		this.latestPriorityFee = mostRecentResult.prioritizationFee;
 		this.lastSlotSeen = mostRecentResult.slot;
 
-		this.lastAvgStrategyResult = this.averageStrategy.calculate(descResults);
-		this.lastMaxStrategyResult = this.maxStrategy.calculate(descResults);
+		this.lastAvgStrategyResult = this.averageStrategy.calculate(resultsToUse);
+		this.lastMaxStrategyResult = this.maxStrategy.calculate(resultsToUse);
 		if (this.customStrategy) {
 			this.lastCustomStrategyResult =
-				this.customStrategy.calculate(descResults);
+				this.customStrategy.calculate(resultsToUse);
 		}
 	}
 

package/src/tx/baseTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSender, TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
 import {
 	Commitment,
 	ConfirmOptions,
@@ -28,6 +28,7 @@ export abstract class BaseTxSender implements TxSender {
 	timeout: number;
 	additionalConnections: Connection[];
 	timeoutCount = 0;
+	confirmationStrategy: ConfirmationStrategy;
 
 	public constructor({
 		connection,
@@ -35,18 +36,21 @@ export abstract class BaseTxSender implements TxSender {
 		opts = AnchorProvider.defaultOptions(),
 		timeout = DEFAULT_TIMEOUT,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
 		opts?: ConfirmOptions;
 		timeout?: number;
 		additionalConnections?;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;
 		this.timeout = timeout;
 		this.additionalConnections = additionalConnections;
+		this.confirmationStrategy = confirmationStrategy;
 	}
 
 	async send(
@@ -156,7 +160,7 @@ export abstract class BaseTxSender implements TxSender {
 		throw new Error('Must be implemented by subclass');
 	}
 
-	async confirmTransaction(
+	async confirmTransactionWebSocket(
 		signature: TransactionSignature,
 		commitment?: Commitment
 	): Promise<RpcResponseAndContext<SignatureResult>> {
@@ -210,6 +214,22 @@ export abstract class BaseTxSender implements TxSender {
 		}
 
 		if (response === null) {
+			if (this.confirmationStrategy === ConfirmationStrategy.Combo) {
+				try {
+					const rpcResponse = await this.connection.getSignatureStatus(
+						signature
+					);
+					if (rpcResponse?.value?.confirmationStatus) {
+						response = {
+							context: rpcResponse.context,
+							value: { err: rpcResponse.value.err },
+						};
+						return response;
+					}
+				} catch (error) {
+					// Ignore error to pass through to timeout error
+				}
+			}
 			this.timeoutCount += 1;
 			const duration = (Date.now() - start) / 1000;
 			throw new Error(
@@ -222,6 +242,48 @@ export abstract class BaseTxSender implements TxSender {
 		return response;
 	}
 
+	async confirmTransactionPolling(
+		signature: TransactionSignature,
+		commitment: Commitment = 'finalized'
+	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
+		let totalTime = 0;
+		let backoffTime = 400; // approx block time
+
+		while (totalTime < this.timeout) {
+			await new Promise((resolve) => setTimeout(resolve, backoffTime));
+
+			const response = await this.connection.getSignatureStatus(signature);
+			const result = response && response.value?.[0];
+
+			if (result && result.confirmationStatus === commitment) {
+				return { context: result.context, value: { err: null } };
+			}
+
+			totalTime += backoffTime;
+			backoffTime = Math.min(backoffTime * 2, 5000);
+		}
+
+		// Transaction not confirmed within 30 seconds
+		this.timeoutCount += 1;
+		throw new Error(
+			`Transaction was not confirmed in 30 seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`
+		);
+	}
+
+	async confirmTransaction(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		if (
+			this.confirmationStrategy === ConfirmationStrategy.WebSocket ||
+			this.confirmationStrategy === ConfirmationStrategy.Combo
+		) {
+			return await this.confirmTransactionWebSocket(signature, commitment);
+		} else if (this.confirmationStrategy === ConfirmationStrategy.Polling) {
+			return await this.confirmTransactionPolling(signature, commitment);
+		}
+	}
+
 	getTimestamp(): number {
 		return new Date().getTime();
 	}

package/src/tx/fastSingleTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSigAndSlot } from './types';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
 import {
 	ConfirmOptions,
 	Signer,
@@ -39,6 +39,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		additionalConnections = new Array<Connection>(),
 		skipConfirmation = false,
 		blockhashCommitment = 'finalized',
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -48,8 +49,16 @@ export class FastSingleTxSender extends BaseTxSender {
 		additionalConnections?;
 		skipConfirmation?: boolean;
 		blockhashCommitment?: Commitment;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
-		super({ connection, wallet, opts, timeout, additionalConnections });
+		super({
+			connection,
+			wallet,
+			opts,
+			timeout,
+			additionalConnections,
+			confirmationStrategy,
+		});
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;

package/src/tx/retryTxSender.ts

@@ -1,9 +1,5 @@
-import { TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	TransactionSignature,
-	Connection,
-} from '@solana/web3.js';
+import { ConfirmationStrategy, TxSigAndSlot } from './types';
+import { ConfirmOptions, Connection } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { IWallet } from '../types';
 import { BaseTxSender } from './baseTxSender';
@@ -31,6 +27,7 @@ export class RetryTxSender extends BaseTxSender {
 		timeout = DEFAULT_TIMEOUT,
 		retrySleep = DEFAULT_RETRY,
 		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
 	}: {
 		connection: Connection;
 		wallet: IWallet;
@@ -38,8 +35,16 @@ export class RetryTxSender extends BaseTxSender {
 		timeout?: number;
 		retrySleep?: number;
 		additionalConnections?;
+		confirmationStrategy?: ConfirmationStrategy;
 	}) {
-		super({ connection, wallet, opts, timeout, additionalConnections });
+		super({
+			connection,
+			wallet,
+			opts,
+			timeout,
+			additionalConnections,
+			confirmationStrategy,
+		});
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;
@@ -61,14 +66,8 @@ export class RetryTxSender extends BaseTxSender {
 	): Promise<TxSigAndSlot> {
 		const startTime = this.getTimestamp();
 
-		let txid: TransactionSignature;
-		try {
-			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-			this.sendToAdditionalConnections(rawTransaction, opts);
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
+		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+		this.sendToAdditionalConnections(rawTransaction, opts);
 
 		let done = false;
 		const resolveReference: ResolveReference = {
@@ -96,16 +95,8 @@ export class RetryTxSender extends BaseTxSender {
 			}
 		})();
 
-		let slot: number;
-		try {
-			const result = await this.confirmTransaction(txid, opts.commitment);
-			slot = result.context.slot;
-		} catch (e) {
-			console.error(e);
-			throw e;
-		} finally {
-			stopWaiting();
-		}
+		const result = await this.confirmTransaction(txid, opts.commitment);
+		const slot = result.context.slot;
 
 		return { txSig: txid, slot };
 	}

package/src/tx/types.ts

@@ -9,6 +9,12 @@ import {
 } from '@solana/web3.js';
 import { IWallet } from '../types';
 
+export enum ConfirmationStrategy {
+	WebSocket = 'websocket',
+	Polling = 'polling',
+	Combo = 'combo',
+}
+
 export type TxSigAndSlot = {
 	txSig: TransactionSignature;
 	slot: number;

package/src/tx/utils.ts

@@ -1,7 +1,9 @@
+import { Wallet } from '@coral-xyz/anchor';
 import {
 	Transaction,
 	TransactionInstruction,
 	ComputeBudgetProgram,
+	VersionedTransaction,
 } from '@solana/web3.js';
 
 const COMPUTE_UNITS_DEFAULT = 200_000;
@@ -30,3 +32,33 @@ export function wrapInTx(
 
 	return tx.add(instruction);
 }
+
+/* Helper function for signing multiple transactions where some may be undefined and mapping the output */
+export async function getSignedTransactionMap(
+	wallet: Wallet,
+	txsToSign: (Transaction | VersionedTransaction | undefined)[],
+	keys: string[]
+): Promise<{ [key: string]: Transaction | VersionedTransaction | undefined }> {
+	const signedTxMap: {
+		[key: string]: Transaction | VersionedTransaction | undefined;
+	} = {};
+
+	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;
+}

package/src/userMap/userMap.ts

@@ -337,6 +337,9 @@ export class UserMap implements UserMapInterface {
 					const userAccount = this.decode('User', buffer);
 					await this.addPubkey(new PublicKey(key), userAccount);
 					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
+				} else {
+					const userAccount = this.decode('User', buffer);
+					this.userMap.get(key).accountSubscriber.updateData(userAccount, slot);
 				}
 				// give event loop a chance to breathe
 				await new Promise((resolve) => setTimeout(resolve, 0));

package/tests/amm/test.ts

@@ -28,6 +28,9 @@ import {
 	squareRootBN,
 	calculateReferencePriceOffset,
 	calculateInventoryLiquidityRatio,
+	ContractTier,
+	isOracleValid,
+	OracleGuardRails,
 } from '../../src';
 import { mockPerpMarkets } from '../dlob/helpers';
 
@@ -875,11 +878,12 @@ describe('AMM Tests', () => {
 		const mockMarket1 = myMockPerpMarkets[0];
 		const mockAmm = mockMarket1.amm;
 		const now = new BN(new Date().getTime() / 1000); //todo
+		const slot = 999999999;
 
 		const oraclePriceData = {
 			price: new BN(13.553 * PRICE_PRECISION.toNumber()),
-			slot: new BN(68 + 1),
-			confidence: new BN(1),
+			slot: new BN(slot),
+			confidence: new BN(1000),
 			hasSufficientNumberOfDataPoints: true,
 		};
 		mockAmm.oracleStd = new BN(0.18 * PRICE_PRECISION.toNumber());
@@ -901,6 +905,127 @@ describe('AMM Tests', () => {
 		const liveOracleStd = calculateLiveOracleStd(mockAmm, oraclePriceData, now);
 		console.log('liveOracleStd:', liveOracleStd.toNumber());
 		assert(liveOracleStd.eq(new BN(192962)));
+
+		const oracleGuardRails: OracleGuardRails = {
+			priceDivergence: {
+				markOraclePercentDivergence: PERCENTAGE_PRECISION.divn(10),
+				oracleTwap5MinPercentDivergence: PERCENTAGE_PRECISION.divn(10),
+			},
+			validity: {
+				slotsBeforeStaleForAmm: new BN(10),
+				slotsBeforeStaleForMargin: new BN(60),
+				confidenceIntervalMaxSize: new BN(20000),
+				tooVolatileRatio: new BN(5),
+			},
+		};
+
+		// good oracle
+		assert(isOracleValid(mockAmm, oraclePriceData, oracleGuardRails, slot + 5));
+
+		// conf too high
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(13.553 * PRICE_PRECISION.toNumber() * 0.021),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// not hasSufficientNumberOfDataPoints
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: false,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// negative oracle price
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(-1 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too delayed for amm
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot + 100
+			)
+		);
+
+		// im passing stale slot (should not call oracle invalid)
+		assert(
+			isOracleValid(
+				mockAmm,
+				{
+					price: new BN(13.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 100),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too volatile (more than 5x higher)
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(113.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 5),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
+
+		// too volatile (more than 1/5 lower)
+		assert(
+			!isOracleValid(
+				mockAmm,
+				{
+					price: new BN(0.553 * PRICE_PRECISION.toNumber()),
+					slot: new BN(slot + 5),
+					confidence: new BN(1),
+					hasSufficientNumberOfDataPoints: true,
+				},
+				oracleGuardRails,
+				slot
+			)
+		);
 	});
 
 	it('predicted funding rate mock1', async () => {
@@ -1065,6 +1190,154 @@ describe('AMM Tests', () => {
 		assert(est2.eq(new BN('-719')));
 	});
 
+	it('predicted funding rate mock clamp', async () => {
+		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
+		const mockMarket1 = myMockPerpMarkets[0];
+
+		// make it like OP
+		const now = new BN(1688881915);
+
+		mockMarket1.amm.fundingPeriod = new BN(3600);
+		mockMarket1.amm.lastFundingRateTs = new BN(1688864415);
+
+		const currentMarkPrice = new BN(1.2242 * PRICE_PRECISION.toNumber()); // trading at a premium
+		const oraclePriceData: OraclePriceData = {
+			price: new BN(1.924 * PRICE_PRECISION.toNumber()),
+			slot: new BN(0),
+			confidence: new BN(1),
+			hasSufficientNumberOfDataPoints: true,
+		};
+		mockMarket1.amm.historicalOracleData.lastOraclePrice = new BN(
+			1.9535 * PRICE_PRECISION.toNumber()
+		);
+
+		// mockMarket1.amm.pegMultiplier = new BN(1.897573 * 1e3);
+
+		mockMarket1.amm.lastMarkPriceTwap = new BN(
+			1.218363 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastBidPriceTwap = new BN(
+			1.218363 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastAskPriceTwap = new BN(
+			1.218364 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.lastMarkPriceTwapTs = new BN(1688878815);
+
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwap = new BN(
+			1.820964 * PRICE_PRECISION.toNumber()
+		);
+		mockMarket1.amm.historicalOracleData.lastOraclePriceTwapTs = new BN(
+			1688879991
+		);
+		mockMarket1.contractTier = ContractTier.A;
+
+		const [
+			_markTwapLive,
+			_oracleTwapLive,
+			_lowerboundEst,
+			_cappedAltEst,
+			_interpEst,
+		] = await calculateAllEstimatedFundingRate(
+			mockMarket1,
+			oraclePriceData,
+			currentMarkPrice,
+			now
+		);
+
+		// console.log(_markTwapLive.toString());
+		// console.log(_oracleTwapLive.toString());
+		// console.log(_lowerboundEst.toString());
+		// console.log(_cappedAltEst.toString());
+		// console.log(_interpEst.toString());
+		// console.log('-----');
+
+		let [markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-126261')));
+
+		mockMarket1.contractTier = ContractTier.C;
+
+		[markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-208332')));
+
+		mockMarket1.contractTier = ContractTier.SPECULATIVE;
+
+		[markTwapLive, oracleTwapLive, est1, est2] =
+			await calculateLongShortFundingRateAndLiveTwaps(
+				mockMarket1,
+				oraclePriceData,
+				currentMarkPrice,
+				now
+			);
+
+		console.log(
+			'markTwapLive:',
+			mockMarket1.amm.lastMarkPriceTwap.toString(),
+			'->',
+			markTwapLive.toString()
+		);
+		console.log(
+			'oracTwapLive:',
+			mockMarket1.amm.historicalOracleData.lastOraclePriceTwap.toString(),
+			'->',
+			oracleTwapLive.toString()
+		);
+		console.log('pred funding:', est1.toString(), est2.toString());
+
+		assert(markTwapLive.eq(new BN('1680634')));
+		assert(oracleTwapLive.eq(new BN('1876031')));
+		assert(est1.eq(est2));
+		assert(est2.eq(new BN('-416666')));
+	});
+
 	it('orderbook L2 gen (no topOfBookQuoteAmounts, 10 numOrders, low liquidity)', async () => {
 		const myMockPerpMarkets = _.cloneDeep(mockPerpMarkets);
 

package/tests/dlob/test.ts

@@ -76,7 +76,7 @@ function insertOrderToDLOB(
 			auctionEndPrice,
 			maxTs,
 		},
-		userAccount,
+		userAccount.toString(),
 		slot.toNumber()
 	);
 }
@@ -127,7 +127,7 @@ function insertTriggerOrderToDLOB(
 			auctionEndPrice,
 			maxTs,
 		},
-		userAccount,
+		userAccount.toString(),
 		slot.toNumber()
 	);
 }