@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/util/TransactionConfirmationManager.ts

@@ -1,333 +0,0 @@
-import {
-	Connection,
-	Context,
-	RpcResponseAndContext,
-	SignatureResult,
-	SignatureStatus,
-	TransactionConfirmationStatus,
-} from '@solana/web3.js';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-import { TxSendError } from '../tx/types';
-import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
-import {
-	getTransactionErrorFromTxSig,
-	throwTransactionError,
-} from '../tx/reportTransactionError';
-import { promiseTimeout } from './promiseTimeout';
-import { ClientSubscriptionId } from '../bankrun/bankrunConnection';
-
-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 600ms, 1200ms, 1800ms, etc.
- */
-export class TransactionConfirmationManager {
-	private connection: Connection;
-	private pendingConfirmations: Map<string, TransactionConfirmationRequest> =
-		new Map();
-	private intervalId: ReturnType<typeof setTimeout> | null = null;
-
-	constructor(connection: Connection) {
-		this.connection = connection;
-	}
-
-	/**
-	 * Waits for a transaction to reach `desiredConfirmationStatus` using a `connection.onSignature`
-	 * websocket subscription, racing it against a one-shot `getSignatureStatuses` check (in case
-	 * the transaction already confirmed before the subscription was established) and a timeout.
-	 * The websocket listener is always removed before returning/throwing.
-	 * @param txSig - Transaction signature to confirm.
-	 * @param timeout - Milliseconds to wait before giving up; defaults to 30000 (30s).
-	 * @param desiredConfirmationStatus - Confirmation level to wait for (`'processed'` <
-	 * `'confirmed'` < `'finalized'`); defaults to `DEFAULT_CONFIRMATION_OPTS.commitment` (`'confirmed'`).
-	 * @returns The RPC response once `txSig` reaches (or exceeds) `desiredConfirmationStatus`.
-	 * @throws Error via `throwTransactionError` if the one-shot status check finds the transaction
-	 * already failed on-chain; `TxSendError` (code `NOT_CONFIRMED_ERROR_CODE`) if neither the
-	 * one-shot check nor the websocket confirms it within `timeout` — in that case the transaction's
-	 * actual outcome is unknown, not necessarily failed.
-	 */
-	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 | undefined;
-
-		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;
-	}
-
-	/**
-	 * Waits for a transaction to reach `desiredConfirmationStatus` by polling
-	 * `getSignatureStatuses` on a shared 100ms tick (see class doc) rather than a
-	 * per-transaction interval — this call registers `txSig` and starts the shared loop if it
-	 * isn't already running.
-	 * @param txSig - Transaction signature to confirm.
-	 * @param desiredConfirmationStatus - Confirmation level to wait for; defaults to
-	 * `DEFAULT_CONFIRMATION_OPTS.commitment` (`'confirmed'`).
-	 * @param timeout - Milliseconds to wait before rejecting; defaults to 30000 (30s).
-	 * @param pollInterval - How often (ms) to actually check this transaction's status against the
-	 * shared 100ms tick; must be at least 400 and a multiple of 100. Defaults to 1000 (1s).
-	 * @param searchTransactionHistory - Whether to also search already-purged ledger history for
-	 * this signature (passed to `getSignatureStatuses`); defaults to `false`. If any transaction
-	 * batched into the same poll round requests this, the whole batch's RPC call requests it.
-	 * @returns The `SignatureStatus` once `txSig` reaches (or exceeds) `desiredConfirmationStatus`.
-	 * @throws Error if `pollInterval` is invalid, if the poll times out, or if the transaction is
-	 * found to have failed on-chain (rejected with the resolved transaction error).
-	 */
-	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);
-				const txError = await getTransactionErrorFromTxSig(
-					request.txSig,
-					this.connection
-				);
-				request.reject(
-					txError ??
-						new Error(
-							`Transaction failed but no error could be resolved for signature ${request.txSig}`
-						)
-				);
-				continue;
-			}
-
-			if (
-				status.confirmationStatus === undefined ||
-				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

@@ -1,65 +0,0 @@
-import { Commitment } from '@solana/web3.js';
-
-/** Last-known chain progress at a given commitment level: block height, slot, and unix timestamp (seconds). Any field may be absent if never observed. */
-export type ChainClockProgress = {
-	blockHeight?: number;
-	slot?: number;
-	ts?: number;
-};
-
-/** A `ChainClockProgress` update tagged with the commitment level it was observed at. */
-export type ChainClockUpdateProps = {
-	commitment: Commitment;
-} & ChainClockProgress;
-
-/** Internal state map: one `ChainClockProgress` per `Commitment` level. */
-export type ChainClockState = Map<Commitment, ChainClockProgress>;
-
-/** Initial per-commitment progress values to seed a `ChainClock` with. */
-export type ChainClickInitialisationProps = ChainClockUpdateProps[];
-
-/**
- * Tracks the most recently observed block height/slot/timestamp per commitment level, so callers
- * (e.g. tx senders deciding whether a blockhash has expired) can read the latest known chain
- * progress without an RPC round-trip.
- */
-export class ChainClock {
-	private _state: ChainClockState;
-
-	/**
-	 * @param props - Initial progress values, one entry per commitment level to track.
-	 */
-	constructor(props: ChainClickInitialisationProps) {
-		this._state = new Map<Commitment, ChainClockUpdateProps>();
-		props.forEach((prop) => {
-			this._state.set(prop.commitment, prop);
-		});
-	}
-
-	/**
-	 * Merges a new observation into the tracked state for `props.commitment`. Only fields present
-	 * on `props` are updated (falsy/omitted `blockHeight`/`slot`/`ts` leave the existing stored
-	 * value untouched, including `0` being treated as absent); the commitment level is created if
-	 * not already tracked.
-	 * @param props - New progress observation, tagged with its commitment level.
-	 */
-	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);
-		}
-	}
-
-	/**
-	 * Reads the last-known progress at a commitment level.
-	 * @param commitment - Commitment level to read.
-	 * @returns The tracked `ChainClockProgress`, or `undefined` if nothing has been observed yet at that level.
-	 */
-	public getState(commitment: Commitment): ChainClockProgress | undefined {
-		return this._state.get(commitment);
-	}
-}

package/src/util/computeUnits.ts

@@ -1,101 +0,0 @@
-import {
-	ComputeBudgetProgram,
-	Connection,
-	Finality,
-	PublicKey,
-	TransactionInstruction,
-} from '@solana/web3.js';
-
-/**
- * Fetches a confirmed transaction and extracts, from its log messages, every "consumed compute
- * units" line attributable to `programId`. A transaction can invoke the same program more than
- * once (e.g. via CPI or multiple instructions), so this returns one entry per matching log line
- * rather than a single total.
- * @param programId - Program whose compute-unit consumption to extract.
- * @param connection - RPC connection used to fetch the transaction.
- * @param txSignature - Signature of the transaction to inspect.
- * @param commitment - Finality level to fetch the transaction at; defaults to `'confirmed'`.
- * @returns The consumed-compute-unit counts (as strings, parsed straight from the log text) for
- * each invocation of `programId` found in the transaction's logs; empty if the transaction has no
- * log messages (e.g. not yet available at the requested commitment).
- */
-export async function findComputeUnitConsumption(
-	programId: PublicKey,
-	connection: Connection,
-	txSignature: string,
-	commitment: Finality = 'confirmed'
-): Promise<string[]> {
-	const tx = await connection.getTransaction(txSignature, { commitment });
-	const computeUnits: string[] = [];
-	const logMessages = tx?.meta?.logMessages;
-	if (!logMessages) {
-		return computeUnits;
-	}
-	const regex = new RegExp(
-		`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`
-	);
-	logMessages.forEach((logMessage) => {
-		const match = logMessage.match(regex);
-		if (match && match[1]) {
-			computeUnits.push(match[1]);
-		}
-	});
-	return computeUnits;
-}
-
-/**
- * Checks whether `ix` is a `ComputeBudgetProgram.setComputeUnitLimit` instruction, by matching
- * the program id and the instruction discriminator byte (`2`).
- * @param ix - Instruction to check.
- * @returns `true` if `ix` sets the transaction's compute unit limit.
- */
-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;
-}
-
-/**
- * Checks whether `ix` is a `ComputeBudgetProgram.setComputeUnitPrice` instruction, by matching
- * the program id and the instruction discriminator byte (`3`).
- * @param ix - Instruction to check.
- * @returns `true` if `ix` sets the transaction's compute unit price (priority fee).
- */
-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;
-}
-
-/**
- * Checks a list of instructions for the presence of compute-budget limit/price instructions —
- * used by tx builders to avoid appending a duplicate `setComputeUnitLimit`/`setComputeUnitPrice`
- * instruction when the caller already supplied one.
- * @param ixs - Instructions to scan (typically an in-progress transaction's instruction list).
- * @returns Whether a `setComputeUnitLimit` and/or `setComputeUnitPrice` instruction is present.
- */
-export function containsComputeUnitIxs(ixs: TransactionInstruction[]): {
-	hasSetComputeUnitLimitIx: boolean;
-	hasSetComputeUnitPriceIx: boolean;
-} {
-	return {
-		hasSetComputeUnitLimitIx: ixs.some(isSetComputeUnitsIx),
-		hasSetComputeUnitPriceIx: ixs.some(isSetComputeUnitPriceIx),
-	};
-}

package/src/util/digest.ts

@@ -1,33 +0,0 @@
-import { createHash } from 'crypto';
-import { nanoid } from 'nanoid';
-
-/**
- * Computes the raw SHA-256 digest of arbitrary data.
- * @param data - Bytes to hash.
- * @returns The 32-byte SHA-256 digest.
- */
-export function digest(data: Buffer): Buffer {
-	const hash = createHash('sha256');
-	hash.update(data);
-	return hash.digest();
-}
-
-/**
- * Computes a base64-encoded SHA-256 digest of a signature, used as a compact, collision-resistant
- * dedup/lookup key for signed messages (e.g. swift/signed-message orders) without storing the full
- * signature.
- * @param signature - Raw signature bytes to hash.
- * @returns The base64-encoded SHA-256 digest.
- */
-export function digestSignature(signature: Uint8Array): string {
-	return createHash('sha256').update(signature).digest('base64');
-}
-
-/**
- * Generates a random 8-character uuid for tagging a signed-message (swift) order, matching the
- * `uuid: Uint8Array` field expected on-chain/by the swift server.
- * @returns 8 raw bytes (the ASCII/UTF-8 encoding of an 8-character nanoid string).
- */
-export function generateSignedMsgUuid(): Uint8Array {
-	return Uint8Array.from(Buffer.from(nanoid(8)));
-}

package/src/util/ed25519Utils.ts

@@ -1,95 +0,0 @@
-import { Ed25519Program, TransactionInstruction } from '@solana/web3.js';
-import * as BufferLayout from '@solana/buffer-layout';
-
-const ED25519_INSTRUCTION_LEN = 16;
-const SIGNATURE_LEN = 64;
-const PUBKEY_LEN = 32;
-const MAGIC_LEN = 4;
-const MESSAGE_SIZE_LEN = 2;
-
-const readUint16LE = (data: Uint8Array, offset: number) => {
-	return data[offset] | (data[offset + 1] << 8);
-};
-
-const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct<
-	Readonly<{
-		messageDataOffset: number;
-		messageDataSize: number;
-		messageInstructionIndex: number;
-		numSignatures: number;
-		padding: number;
-		publicKeyInstructionIndex: number;
-		publicKeyOffset: number;
-		signatureInstructionIndex: number;
-		signatureOffset: number;
-	}>
->([
-	BufferLayout.u8('numSignatures'),
-	BufferLayout.u8('padding'),
-	BufferLayout.u16('signatureOffset'),
-	BufferLayout.u16('signatureInstructionIndex'),
-	BufferLayout.u16('publicKeyOffset'),
-	BufferLayout.u16('publicKeyInstructionIndex'),
-	BufferLayout.u16('messageDataOffset'),
-	BufferLayout.u16('messageDataSize'),
-	BufferLayout.u16('messageInstructionIndex'),
-]);
-
-/**
- * Constructs a minimal Ed25519 verification instruction that, instead of embedding its own copy
- * of the signature/pubkey/message, points its offsets at data already present inside another
- * instruction in the same transaction (e.g. `postPythLazerOracleUpdate`, `placeSignedMsgTakerOrder`).
- * This lets the native ed25519 program verify a signature the velocity program also needs to read,
- * without duplicating the signed payload in the transaction (which would blow the size limit for
- * larger payloads like Lazer updates). The Solana runtime requires this ed25519 verify instruction
- * to be a sibling instruction (not a CPI) executed before the instruction that relies on it.
- *
- * @param customInstructionIndex The index of the custom instruction in the transaction (e.g. if tx contains compute budget limit, compute budget price, ed25519 verify, custom ix, this would be 3).
- * @param messageOffset The offset within the custom instruction data where the signed message begins.
- * @param customInstructionData The entire instruction data array for the custom instruction.
- * @param magicLen Length, in bytes, of a "magic"/tag prefix between `messageOffset` and the
- * start of the 64-byte signature; defaults to `MAGIC_LEN` (4) if omitted.
- * @returns A `TransactionInstruction` targeting `Ed25519Program` with no accounts, whose data
- * encodes offsets (not copies) of the signature/pubkey/message living inside the referenced
- * custom instruction.
- */
-export function createMinimalEd25519VerifyIx(
-	customInstructionIndex: number,
-	messageOffset: number,
-	customInstructionData: Uint8Array,
-	magicLen?: number
-): TransactionInstruction {
-	const signatureOffset =
-		messageOffset + (magicLen === undefined ? MAGIC_LEN : magicLen);
-	const publicKeyOffset = signatureOffset + SIGNATURE_LEN;
-	const messageDataSizeOffset = publicKeyOffset + PUBKEY_LEN;
-	const messageDataOffset = messageDataSizeOffset + MESSAGE_SIZE_LEN;
-
-	const messageDataSize = readUint16LE(
-		customInstructionData,
-		messageDataSizeOffset - messageOffset
-	);
-
-	const instructionData = Buffer.alloc(ED25519_INSTRUCTION_LEN);
-
-	ED25519_INSTRUCTION_LAYOUT.encode(
-		{
-			numSignatures: 1,
-			padding: 0,
-			signatureOffset,
-			signatureInstructionIndex: customInstructionIndex,
-			publicKeyOffset,
-			publicKeyInstructionIndex: customInstructionIndex,
-			messageDataOffset,
-			messageDataSize: messageDataSize,
-			messageInstructionIndex: customInstructionIndex,
-		},
-		instructionData
-	);
-
-	return new TransactionInstruction({
-		keys: [],
-		programId: Ed25519Program.programId,
-		data: instructionData,
-	});
-}

package/src/util/promiseTimeout.ts

@@ -1,23 +0,0 @@
-/**
- * Races `promise` against a timer, resolving to `null` instead of rejecting/hanging if `promise`
- * doesn't settle within `timeoutMs`. `promise` itself is not cancelled — it keeps running in the
- * background and its eventual result/rejection is discarded once the race is decided.
- * @param promise - The promise to await.
- * @param timeoutMs - Timeout in milliseconds.
- * @returns `promise`'s resolved value, or `null` if it didn't settle before `timeoutMs` elapsed.
- * Rejects if `promise` rejects before the timeout.
- */
-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;
-	});
-}