@drift-labs/sdk-browser 2.104.0-beta.21

package/src/util/TransactionConfirmationManager.ts

@@ -0,0 +1,292 @@
+import {
+	ClientSubscriptionId,
+	Connection,
+	Context,
+	RpcResponseAndContext,
+	SignatureResult,
+	SignatureStatus,
+	TransactionConfirmationStatus,
+} from '@solana/web3.js';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+import { TxSendError } from '..';
+import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
+import {
+	getTransactionErrorFromTxSig,
+	throwTransactionError,
+} from '../tx/reportTransactionError';
+import { promiseTimeout } from './promiseTimeout';
+
+type ResolveReference = {
+	resolve?: () => void;
+};
+
+const confirmationStatusValues: Record<TransactionConfirmationStatus, number> =
+	{
+		processed: 0,
+		confirmed: 1,
+		finalized: 2,
+	};
+
+interface TransactionConfirmationRequest {
+	txSig: string;
+	desiredConfirmationStatus: TransactionConfirmationStatus;
+	timeout: number;
+	pollInterval: number;
+	searchTransactionHistory: boolean;
+	startTime: number;
+	resolve: (status: SignatureStatus) => void;
+	reject: (error: Error) => void;
+}
+
+/**
+ * Class to await for transaction confirmations in an optimised manner. It tracks a shared list of all pending transactions and fetches them in bulk in a shared RPC request whenever they have an "overlapping" polling interval. E.g. tx1 with an interval of 200ms and tx2 with an interval of 300ms (if sent at the same time) will be fetched together at at 600ms, 1200ms, 1800ms, etc.
+ */
+export class TransactionConfirmationManager {
+	private connection: Connection;
+	private pendingConfirmations: Map<string, TransactionConfirmationRequest> =
+		new Map();
+	private intervalId: NodeJS.Timeout | null = null;
+
+	constructor(connection: Connection) {
+		this.connection = connection;
+	}
+
+	async confirmTransactionWebSocket(
+		txSig: string,
+		timeout = 30000,
+		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		const start = Date.now();
+		const subscriptionCommitment =
+			desiredConfirmationStatus || DEFAULT_CONFIRMATION_OPTS.commitment;
+
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+
+		let subscriptionId: ClientSubscriptionId;
+
+		const confirmationPromise = new Promise((resolve, reject) => {
+			try {
+				subscriptionId = this.connection.onSignature(
+					txSig,
+					(result: SignatureResult, context: Context) => {
+						response = {
+							context,
+							value: result,
+						};
+						resolve(null);
+					},
+					subscriptionCommitment
+				);
+			} catch (err) {
+				reject(err);
+			}
+		});
+
+		// We do a one-shot confirmation check just in case the transaction is ALREADY confirmed when we create the websocket confirmation .. We want to run this concurrently with the onSignature subscription. If this returns true then we can return early as the transaction has already been confirmed.
+		const oneShotConfirmationPromise = this.connection.getSignatureStatuses([
+			txSig,
+		]);
+
+		const resolveReference: ResolveReference = {};
+
+		// This is the promise we are waiting on to resolve the overall confirmation. It will resolve the faster of a positive oneShot confirmation, or the websocket confirmation, or the timeout.
+		const overallWaitingForConfirmationPromise = new Promise<void>(
+			(resolve) => {
+				resolveReference.resolve = resolve;
+			}
+		);
+
+		// Await for the one shot confirmation and resolve the waiting promise if we get a positive confirmation result
+		oneShotConfirmationPromise.then(
+			async (oneShotResponse) => {
+				if (!oneShotResponse || !oneShotResponse?.value?.[0]) return;
+
+				const resultValue = oneShotResponse.value[0];
+
+				if (resultValue.err) {
+					await throwTransactionError(txSig, this.connection);
+				}
+
+				if (
+					this.checkStatusMatchesDesiredConfirmationStatus(
+						resultValue,
+						desiredConfirmationStatus
+					)
+				) {
+					response = {
+						context: oneShotResponse.context,
+						value: oneShotResponse.value[0],
+					};
+					resolveReference.resolve?.();
+				}
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		// Await for the websocket confirmation with the configured timeout
+		promiseTimeout(confirmationPromise, timeout).then(
+			() => {
+				resolveReference.resolve?.();
+			},
+			(onRejected) => {
+				throw onRejected;
+			}
+		);
+
+		try {
+			await overallWaitingForConfirmationPromise;
+		} finally {
+			if (subscriptionId !== undefined) {
+				this.connection.removeSignatureListener(subscriptionId);
+			}
+		}
+
+		const duration = (Date.now() - start) / 1000;
+
+		if (response === null) {
+			throw new TxSendError(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${txSig} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
+			);
+		}
+
+		return response;
+	}
+
+	async confirmTransactionPolling(
+		txSig: string,
+		desiredConfirmationStatus = DEFAULT_CONFIRMATION_OPTS.commitment as TransactionConfirmationStatus,
+		timeout = 30000,
+		pollInterval = 1000,
+		searchTransactionHistory = false
+	): Promise<SignatureStatus> {
+		// Interval must be > 400ms and a multiple of 100ms
+		if (pollInterval < 400 || pollInterval % 100 !== 0) {
+			throw new Error(
+				'Transaction confirmation polling interval must be at least 400ms and a multiple of 100ms'
+			);
+		}
+
+		return new Promise((resolve, reject) => {
+			this.pendingConfirmations.set(txSig, {
+				txSig,
+				desiredConfirmationStatus,
+				timeout,
+				pollInterval,
+				searchTransactionHistory,
+				startTime: Date.now(),
+				resolve,
+				reject,
+			});
+
+			if (!this.intervalId) {
+				this.startConfirmationLoop();
+			}
+		});
+	}
+
+	private startConfirmationLoop() {
+		this.intervalId = setInterval(() => this.checkPendingConfirmations(), 100);
+	}
+
+	private async checkPendingConfirmations() {
+		const now = Date.now();
+		const transactionsToCheck: TransactionConfirmationRequest[] = [];
+
+		for (const [txSig, request] of this.pendingConfirmations.entries()) {
+			if (now - request.startTime >= request.timeout) {
+				request.reject(
+					new Error(
+						`Transaction confirmation timeout after ${request.timeout}ms`
+					)
+				);
+				this.pendingConfirmations.delete(txSig);
+			} else if ((now - request.startTime) % request.pollInterval < 100) {
+				transactionsToCheck.push(request);
+			}
+		}
+
+		if (transactionsToCheck.length > 0) {
+			await this.checkTransactionStatuses(transactionsToCheck);
+		}
+
+		if (this.pendingConfirmations.size === 0 && this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = null;
+		}
+	}
+
+	private checkStatusMatchesDesiredConfirmationStatus(
+		status: SignatureStatus,
+		desiredConfirmationStatus: TransactionConfirmationStatus
+	): boolean {
+		if (
+			status.confirmationStatus &&
+			confirmationStatusValues[status.confirmationStatus] >=
+				confirmationStatusValues[desiredConfirmationStatus]
+		) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private async checkTransactionStatuses(
+		requests: TransactionConfirmationRequest[]
+	) {
+		const txSigs = requests.map((request) => request.txSig);
+		const { value: statuses } = await this.connection.getSignatureStatuses(
+			txSigs,
+			{
+				searchTransactionHistory: requests.some(
+					(req) => req.searchTransactionHistory
+				),
+			}
+		);
+
+		if (!statuses || statuses.length !== txSigs.length) {
+			throw new Error('Failed to get signature statuses');
+		}
+
+		for (let i = 0; i < statuses.length; i++) {
+			const status = statuses[i];
+			const request = requests[i];
+
+			if (status === null) {
+				continue;
+			}
+
+			if (status.err) {
+				this.pendingConfirmations.delete(request.txSig);
+				request.reject(
+					await getTransactionErrorFromTxSig(request.txSig, this.connection)
+				);
+				continue;
+			}
+
+			if (
+				confirmationStatusValues[status.confirmationStatus] === undefined ||
+				confirmationStatusValues[request.desiredConfirmationStatus] ===
+					undefined
+			) {
+				throw new Error(
+					`Invalid confirmation status when awaiting confirmation: ${status.confirmationStatus}`
+				);
+			}
+
+			if (
+				this.checkStatusMatchesDesiredConfirmationStatus(
+					status,
+					request.desiredConfirmationStatus
+				)
+			) {
+				request.resolve(status);
+				this.pendingConfirmations.delete(request.txSig);
+			}
+		}
+	}
+}

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/src/util/computeUnits.ts

@@ -0,0 +1,65 @@
+import {
+	ComputeBudgetProgram,
+	Connection,
+	Finality,
+	PublicKey,
+	TransactionInstruction,
+} from '@solana/web3.js';
+
+export async function findComputeUnitConsumption(
+	programId: PublicKey,
+	connection: Connection,
+	txSignature: string,
+	commitment: Finality = 'confirmed'
+): Promise<number[]> {
+	const tx = await connection.getTransaction(txSignature, { commitment });
+	const computeUnits = [];
+	const regex = new RegExp(
+		`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`
+	);
+	tx.meta.logMessages.forEach((logMessage) => {
+		const match = logMessage.match(regex);
+		if (match && match[1]) {
+			computeUnits.push(match[1]);
+		}
+	});
+	return computeUnits;
+}
+
+export function isSetComputeUnitsIx(ix: TransactionInstruction): boolean {
+	// Compute budget program discriminator is first byte
+	// 2: set compute unit limit
+	// 3: set compute unit price
+	if (
+		ix.programId.equals(ComputeBudgetProgram.programId) &&
+		// @ts-ignore
+		ix.data.at(0) === 2
+	) {
+		return true;
+	}
+	return false;
+}
+
+export function isSetComputeUnitPriceIx(ix: TransactionInstruction): boolean {
+	// Compute budget program discriminator is first byte
+	// 2: set compute unit limit
+	// 3: set compute unit price
+	if (
+		ix.programId.equals(ComputeBudgetProgram.programId) &&
+		// @ts-ignore
+		ix.data.at(0) === 3
+	) {
+		return true;
+	}
+	return false;
+}
+
+export function containsComputeUnitIxs(ixs: TransactionInstruction[]): {
+	hasSetComputeUnitLimitIx: boolean;
+	hasSetComputeUnitPriceIx: boolean;
+} {
+	return {
+		hasSetComputeUnitLimitIx: ixs.some(isSetComputeUnitsIx),
+		hasSetComputeUnitPriceIx: ixs.some(isSetComputeUnitPriceIx),
+	};
+}

package/src/util/digest.ts

@@ -0,0 +1,11 @@
+import { createHash } from 'crypto';
+
+export function digest(data: Buffer): Buffer {
+	const hash = createHash('sha256');
+	hash.update(data);
+	return hash.digest();
+}
+
+export function digestSignature(signature: Uint8Array): string {
+	return createHash('sha256').update(signature).digest('base64');
+}

package/src/util/promiseTimeout.ts

@@ -0,0 +1,14 @@
+export function promiseTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number
+): Promise<T | null> {
+	let timeoutId: ReturnType<typeof setTimeout>;
+	const timeoutPromise: Promise<null> = new Promise((resolve) => {
+		timeoutId = setTimeout(() => resolve(null), timeoutMs);
+	});
+
+	return Promise.race([promise, timeoutPromise]).then((result: T | null) => {
+		clearTimeout(timeoutId);
+		return result;
+	});
+}

package/src/util/pythOracleUtils.ts

@@ -0,0 +1,136 @@
+import {
+	SYSVAR_INSTRUCTIONS_PUBKEY,
+	TransactionInstruction,
+	Ed25519Program,
+} from '@solana/web3.js';
+
+export function trimFeedId(feedId: string): string {
+	if (feedId.startsWith('0x')) {
+		return feedId.slice(2);
+	}
+	return feedId;
+}
+
+export function getFeedIdUint8Array(feedId: string): Uint8Array {
+	const trimmedFeedId = trimFeedId(feedId);
+	return Uint8Array.from(Buffer.from(trimmedFeedId, 'hex'));
+}
+
+const SIGNATURE_LEN = 64;
+const PUBKEY_LEN = 32;
+const MAGIC_LEN = 4;
+const MESSAGE_SIZE_LEN = 2;
+
+export function getEd25519ArgsFromHex(hex: string): {
+	publicKey: Uint8Array;
+	signature: Uint8Array;
+	message: Uint8Array;
+} {
+	const cleanedHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+	const buffer = new Uint8Array(Buffer.from(cleanedHex, 'hex'));
+
+	const signatureOffset = MAGIC_LEN;
+	const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+	const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+	const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+
+	const signature = buffer.slice(
+		signatureOffset,
+		signatureOffset + SIGNATURE_LEN
+	);
+	const publicKey = buffer.slice(publicKeyOffset, publicKeyOffset + PUBKEY_LEN);
+	const messageSize =
+		buffer[messageDataSizeOffset] | (buffer[messageDataSizeOffset + 1] << 8);
+	const message = buffer.slice(
+		messageDataOffset,
+		messageDataOffset + messageSize
+	);
+
+	if (publicKey.length !== PUBKEY_LEN) {
+		throw new Error('Invalid public key length');
+	}
+
+	if (signature.length !== SIGNATURE_LEN) {
+		throw new Error('Invalid signature length');
+	}
+
+	return {
+		publicKey,
+		signature,
+		message,
+	};
+}
+
+/**
+ * Constructs a minimal Ed25519 verification instruction that references the data
+ * inside the main instruction (postPythLazerOracleUpdate).
+ *
+ * @param customInstructionIndex The index of the custom instruction in the transaction (typically 1 if this is second).
+ * @param messageOffset The offset within the custom instruction data where the pythMessage begins.
+ * @param customInstructionData The entire instruction data array for the custom instruction.
+ */
+export function createMinimalEd25519VerifyIx(
+	customInstructionIndex: number,
+	messageOffset: number,
+	customInstructionData: Uint8Array
+): TransactionInstruction {
+	const signatureOffset = messageOffset + MAGIC_LEN;
+	const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
+	const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
+	const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
+
+	if (messageDataOffset > customInstructionData.length) {
+		throw new Error('Not enough data in main instruction to read message size');
+	}
+
+	const messageSize =
+		customInstructionData[messageDataSizeOffset] |
+		(customInstructionData[messageDataSizeOffset + 1] << 8);
+
+	// Construct Ed25519SignatureOffsets
+	// struct Ed25519SignatureOffsets (14 bytes):
+	// u16 signature_offset
+	// u16 signature_instruction_index
+	// u16 public_key_offset
+	// u16 public_key_instruction_index
+	// u16 message_data_offset
+	// u16 message_data_size
+	// u16 message_instruction_index
+	const offsets = new Uint8Array(14);
+	const dv = new DataView(offsets.buffer);
+
+	let byteOffset = 0;
+	dv.setUint16(byteOffset, signatureOffset, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, customInstructionIndex, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, publicKeyOffset, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, customInstructionIndex, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, messageDataOffset, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, messageSize, true);
+	byteOffset += 2;
+	dv.setUint16(byteOffset, customInstructionIndex, true);
+	byteOffset += 2;
+
+	const numSignatures = 1;
+	const padding = 0;
+	const ixData = new Uint8Array(2 + offsets.length);
+	ixData[0] = numSignatures;
+	ixData[1] = padding;
+	ixData.set(offsets, 2);
+
+	return new TransactionInstruction({
+		keys: [
+			{
+				pubkey: SYSVAR_INSTRUCTIONS_PUBKEY,
+				isSigner: false,
+				isWritable: false,
+			},
+		],
+		programId: Ed25519Program.programId,
+		data: Buffer.from(ixData),
+	});
+}

package/src/util/tps.ts

@@ -0,0 +1,27 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+
+export async function estimateTps(
+	programId: PublicKey,
+	connection: Connection,
+	failed: boolean
+): Promise<number> {
+	let signatures = await connection.getSignaturesForAddress(
+		programId,
+		undefined,
+		'finalized'
+	);
+	if (failed) {
+		signatures = signatures.filter((signature) => signature.err);
+	}
+
+	const numberOfSignatures = signatures.length;
+
+	if (numberOfSignatures === 0) {
+		return 0;
+	}
+
+	return (
+		numberOfSignatures /
+		(signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime)
+	);
+}

package/src/wallet.ts

@@ -0,0 +1,43 @@
+import {
+	Keypair,
+	PublicKey,
+	Transaction,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { IWallet, IVersionedWallet } from './types';
+
+export class Wallet implements IWallet, IVersionedWallet {
+	constructor(readonly payer: Keypair) {}
+
+	async signTransaction(tx: Transaction): Promise<Transaction> {
+		tx.partialSign(this.payer);
+		return tx;
+	}
+
+	async signVersionedTransaction(
+		tx: VersionedTransaction
+	): Promise<VersionedTransaction> {
+		tx.sign([this.payer]);
+		return tx;
+	}
+
+	async signAllTransactions(txs: Transaction[]): Promise<Transaction[]> {
+		return txs.map((t) => {
+			t.partialSign(this.payer);
+			return t;
+		});
+	}
+
+	async signAllVersionedTransactions(
+		txs: VersionedTransaction[]
+	): Promise<VersionedTransaction[]> {
+		return txs.map((t) => {
+			t.sign([this.payer]);
+			return t;
+		});
+	}
+
+	get publicKey(): PublicKey {
+		return this.payer.publicKey;
+	}
+}