@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/tx/blockhashFetcher/cachedBlockhashFetcher.ts

@@ -1,105 +0,0 @@
-import {
-	BlockhashWithExpiryBlockHeight,
-	Commitment,
-	Connection,
-} from '@solana/web3.js';
-import { BlockhashFetcher } from './types';
-
-/**
- * Fetches the latest blockhash and caches it for a configurable amount of time.
- *
- * - Prevents RPC spam by reusing cached values
- * - Retries on failure with exponential backoff
- * - Prevents concurrent requests for the same blockhash
- */
-export class CachedBlockhashFetcher implements BlockhashFetcher {
-	private recentBlockhashCache: {
-		value: BlockhashWithExpiryBlockHeight | undefined;
-		lastUpdated: number;
-	} = { value: undefined, lastUpdated: 0 };
-
-	private blockhashFetchingPromise: Promise<void> | null = null;
-
-	/**
-	 * @param connection - RPC connection to fetch the blockhash from.
-	 * @param blockhashCommitment - Commitment level to request the blockhash at.
-	 * @param retryCount - Maximum fetch attempts before giving up and throwing.
-	 * @param retrySleepTimeMs - Base backoff delay (ms) between retries; doubles each attempt (`retrySleepTimeMs * 2^i`).
-	 * @param staleCacheTimeMs - How long (ms) a cached blockhash is served before a refresh is triggered.
-	 */
-	constructor(
-		private connection: Connection,
-		private blockhashCommitment: Commitment,
-		private retryCount: number,
-		private retrySleepTimeMs: number,
-		private staleCacheTimeMs: number
-	) {}
-
-	private async fetchBlockhashWithRetry(): Promise<BlockhashWithExpiryBlockHeight> {
-		for (let i = 0; i < this.retryCount; i++) {
-			try {
-				return await this.connection.getLatestBlockhash(
-					this.blockhashCommitment
-				);
-			} catch (err) {
-				if (i === this.retryCount - 1) {
-					throw new Error('Failed to fetch blockhash after maximum retries');
-				}
-				await this.sleep(this.retrySleepTimeMs * 2 ** i);
-			}
-		}
-		throw new Error('Failed to fetch blockhash after maximum retries');
-	}
-
-	private sleep(ms: number): Promise<void> {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-
-	private async updateBlockhashCache(): Promise<void> {
-		const result = await this.fetchBlockhashWithRetry();
-		this.recentBlockhashCache = {
-			value: result,
-			lastUpdated: Date.now(),
-		};
-	}
-
-	/**
-	 * Returns the cached blockhash, refreshing it first if the cache is older than
-	 * `staleCacheTimeMs`. Concurrent calls during a refresh all await the same in-flight fetch
-	 * rather than issuing duplicate RPC requests.
-	 * @returns The latest (possibly cached) blockhash and its expiry block height.
-	 * @throws If no cached value exists yet and the initial fetch fails after exhausting
-	 * `retryCount` retries.
-	 */
-	public async getLatestBlockhash(): Promise<
-		BlockhashWithExpiryBlockHeight | undefined
-	> {
-		if (this.isCacheStale()) {
-			await this.refreshBlockhash();
-		}
-		return this.recentBlockhashCache.value;
-	}
-
-	private isCacheStale(): boolean {
-		const lastUpdateTime = this.recentBlockhashCache.lastUpdated;
-		return (
-			!lastUpdateTime || Date.now() > lastUpdateTime + this.staleCacheTimeMs
-		);
-	}
-
-	/**
-	 * Refresh the blockhash cache, await a pending refresh if it exists
-	 */
-	private async refreshBlockhash(): Promise<void> {
-		if (!this.blockhashFetchingPromise) {
-			this.blockhashFetchingPromise = this.updateBlockhashCache();
-			try {
-				await this.blockhashFetchingPromise;
-			} finally {
-				this.blockhashFetchingPromise = null;
-			}
-		} else {
-			await this.blockhashFetchingPromise;
-		}
-	}
-}

package/src/tx/blockhashFetcher/types.ts

@@ -1,9 +0,0 @@
-import { BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
-
-/** Strategy interface for obtaining a recent blockhash, abstracting whether it's fetched fresh every call or cached (see `BaseBlockhashFetcher`/`CachedBlockhashFetcher`). */
-export interface BlockhashFetcher {
-	/**
-	 * @returns The latest blockhash and its expiry block height, or `undefined` if unavailable.
-	 */
-	getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
-}

package/src/tx/fastSingleTxSender.ts

@@ -1,200 +0,0 @@
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	TransactionSignature,
-	Connection,
-	Commitment,
-	BlockhashWithExpiryBlockHeight,
-} from '@solana/web3.js';
-import { BaseTxSender } from './baseTxSender';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-const DEFAULT_TIMEOUT = 35000;
-const DEFAULT_BLOCKHASH_REFRESH = 10000;
-
-/**
- * `TxSender` optimized for low latency: sends a transaction exactly once (no resend/retry loop —
- * relies on the RPC node's own forwarding), and can skip confirmation entirely or confirm
- * asynchronously in the background so `sendRawTransaction` returns as soon as the send lands.
- * Maintains its own periodically-refreshed blockhash cache (independent of `TxHandler`'s) purely
- * for that background-refresh convenience; it is not actually consumed by `sendRawTransaction`
- * here. Suited to latency-sensitive keeper bots that would rather fire-and-forget than pay for
- * `RetryTxSender`'s resend loop.
- */
-export class FastSingleTxSender extends BaseTxSender {
-	connection: Connection;
-	wallet: IWallet;
-	opts: ConfirmOptions;
-	timeout: number;
-	/** How often (ms) `startBlockhashRefreshLoop` refreshes `recentBlockhash`; `0` disables the refresh loop. */
-	blockhashRefreshInterval: number;
-	additionalConnections: Connection[];
-	timoutCount = 0;
-	/** Periodically refreshed blockhash cache (see `startBlockhashRefreshLoop`); informational only — `sendRawTransaction` does not currently read this field. */
-	recentBlockhash?: BlockhashWithExpiryBlockHeight;
-	/** If `true`, `sendRawTransaction` returns immediately after sending, without waiting for or checking confirmation. */
-	skipConfirmation: boolean;
-	/** If `true` (and `skipConfirmation` is `false`), confirmation runs without being awaited — `sendRawTransaction` returns before the transaction is confirmed. */
-	confirmInBackground: boolean;
-	/** Commitment level used when refreshing `recentBlockhash`. */
-	blockhashCommitment: Commitment;
-	/** Handle for the interval timer started by `startBlockhashRefreshLoop`. */
-	blockhashIntervalId?: NodeJS.Timer;
-
-	/**
-	 * @param props.connection - RPC connection used for sending, confirming, and blockhash refresh.
-	 * @param props.wallet - Wallet used to sign transactions that aren't already `preSigned`.
-	 * @param props.opts - Default `ConfirmOptions`; defaults to `DEFAULT_CONFIRMATION_OPTS` with `maxRetries: 0` (this sender does not retry sends itself).
-	 * @param props.timeout - Confirmation timeout in milliseconds; defaults to 35000 (35s).
-	 * @param props.blockhashRefreshInterval - Interval (ms) for the background blockhash refresh; defaults to 10000 (10s). `0` disables it.
-	 * @param props.additionalConnections - Extra connections to also broadcast raw transactions to.
-	 * @param props.skipConfirmation - Skip confirmation entirely after sending; defaults to `false`.
-	 * @param props.confirmInBackground - Confirm without awaiting, so `sendRawTransaction` resolves right after send; defaults to `false`.
-	 * @param props.blockhashCommitment - Commitment for the background blockhash refresh; defaults to `'finalized'`.
-	 * @param props.confirmationStrategy - How to wait for confirmation; defaults to `ConfirmationStrategy.Combo`.
-	 * @param props.trackTxLandRate - Enables land-rate tracking.
-	 * @param props.txHandler - Custom `TxHandler` for signing/building transactions.
-	 * @param props.txLandRateLookbackWindowMinutes - Rolling window, in minutes, for the land-rate calculation.
-	 * @param props.landRateToFeeFunc - Custom mapping from land rate to priority-fee multiplier.
-	 * @param props.throwOnTimeoutError - Whether confirmation timeouts throw `TxSendError`; defaults to `true`.
-	 */
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		timeout = DEFAULT_TIMEOUT,
-		blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH,
-		additionalConnections = new Array<Connection>(),
-		skipConfirmation = false,
-		confirmInBackground = false,
-		blockhashCommitment = 'finalized',
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		trackTxLandRate,
-		txHandler,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		timeout?: number;
-		blockhashRefreshInterval?: number;
-		additionalConnections?: Connection[];
-		skipConfirmation?: boolean;
-		confirmInBackground?: boolean;
-		blockhashCommitment?: Commitment;
-		confirmationStrategy?: ConfirmationStrategy;
-		trackTxLandRate?: boolean;
-		txHandler?: TxHandler;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			timeout,
-			additionalConnections,
-			confirmationStrategy,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-		});
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.timeout = timeout;
-		this.blockhashRefreshInterval = blockhashRefreshInterval;
-		this.additionalConnections = additionalConnections;
-		this.skipConfirmation = skipConfirmation;
-		this.confirmInBackground = confirmInBackground;
-		this.blockhashCommitment = blockhashCommitment;
-		this.startBlockhashRefreshLoop();
-	}
-
-	/**
-	 * Starts a `setInterval` loop (if `blockhashRefreshInterval > 0`) that refreshes
-	 * `this.recentBlockhash` every `blockhashRefreshInterval` ms. Fetch errors are logged and
-	 * otherwise ignored (the loop keeps running with the stale cached value).
-	 */
-	startBlockhashRefreshLoop(): void {
-		if (this.blockhashRefreshInterval > 0) {
-			this.blockhashIntervalId = setInterval(async () => {
-				try {
-					this.recentBlockhash = await this.connection.getLatestBlockhash(
-						this.blockhashCommitment
-					);
-				} catch (e) {
-					console.error('Error in startBlockhashRefreshLoop: ', e);
-				}
-			}, this.blockhashRefreshInterval);
-		}
-	}
-
-	/**
-	 * Sends a raw transaction exactly once via `connection.sendRawTransaction` (plus a best-effort
-	 * broadcast to `additionalConnections`), then confirms it unless `skipConfirmation` is set —
-	 * awaited normally, or fired without awaiting if `confirmInBackground` is set (in which case
-	 * the returned `slot` will be `undefined`, since it isn't known yet at return time).
-	 * @param rawTransaction - Serialized, signed transaction bytes.
-	 * @param opts - Options passed to `sendRawTransaction`/`confirmTransaction`; `opts.commitment` selects confirmation level.
-	 * @returns The signature, and the confirmation slot if confirmation completed synchronously (`undefined` if `skipConfirmation` or `confirmInBackground` is set).
-	 * @throws Whatever `connection.sendRawTransaction` or (if awaited) `confirmTransaction`/`checkConfirmationResultForError` throw.
-	 */
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		let txid: TransactionSignature;
-		try {
-			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-			this.txSigCache?.set(txid, false);
-			this.sendToAdditionalConnections(rawTransaction, opts);
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
-
-		let slot: number | undefined;
-		if (!this.skipConfirmation) {
-			try {
-				if (this.confirmInBackground) {
-					this.confirmTransaction(txid, opts.commitment)
-						.then(async (result) => {
-							this.txSigCache?.set(txid, true);
-							if (result) {
-								await this.checkConfirmationResultForError(txid, result.value);
-								slot = result.context.slot;
-							}
-						})
-						.catch((err) => {
-							// background confirmation is fire-and-forget; surface failures
-							// in logs instead of as unhandled promise rejections
-							console.error(
-								`Error confirming transaction ${txid} in background:`,
-								err
-							);
-						});
-				} else {
-					const result = await this.confirmTransaction(txid, opts.commitment);
-					this.txSigCache?.set(txid, true);
-					if (result) {
-						await this.checkConfirmationResultForError(txid, result.value);
-						slot = result.context.slot;
-					}
-				}
-			} catch (e) {
-				console.error(e);
-				throw e;
-			}
-		}
-
-		return { txSig: txid, slot };
-	}
-}

package/src/tx/forwardOnlyTxSender.ts

@@ -1,193 +0,0 @@
-import {
-	ConfirmOptions,
-	Connection,
-	VersionedTransaction,
-} from '@solana/web3.js';
-import bs58 from 'bs58';
-import { BaseTxSender } from './baseTxSender';
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-const DEFAULT_TIMEOUT = 35000;
-const DEFAULT_RETRY = 5000;
-
-type ResolveReference = {
-	resolve?: () => void;
-};
-
-/**
- * `TxSender` that never calls `connection.sendRawTransaction` itself — instead it hands the raw
- * transaction to `additionalTxSenderCallbacks` (e.g. a Jito/third-party bundle submitter) and
- * re-invokes those callbacks on a `retrySleep` interval until the transaction confirms or
- * `timeout` elapses. `connection` is used only to *confirm* the transaction (via
- * `BaseTxSender.confirmTransaction`), never to broadcast it. `additionalConnections` is always
- * empty for this sender (the constructor doesn't accept it) since forwarding goes exclusively
- * through the callbacks.
- *
- * Use this when transaction submission is delegated to an external forwarder/relay rather than
- * this RPC connection, but you still want this SDK's confirmation/retry/land-rate machinery.
- */
-export class ForwardOnlyTxSender extends BaseTxSender {
-	connection: Connection;
-	wallet: IWallet;
-	opts: ConfirmOptions;
-	timeout: number;
-	retrySleep: number;
-	additionalConnections: Connection[];
-	timoutCount = 0;
-
-	/**
-	 * @param props.connection - RPC connection used only for confirmation, never for sending.
-	 * @param props.wallet - Wallet used to sign transactions that aren't already `preSigned`.
-	 * @param props.opts - Default `ConfirmOptions`; defaults to `DEFAULT_CONFIRMATION_OPTS` with `maxRetries: 0` (retries are handled by this sender's own re-forward loop, not the RPC node).
-	 * @param props.timeout - Total time (ms) to keep re-forwarding and waiting for confirmation before giving up; defaults to 35000 (35s).
-	 * @param props.retrySleep - Interval (ms) between re-invocations of `additionalTxSenderCallbacks`; defaults to 5000 (5s).
-	 * @param props.confirmationStrategy - How to wait for confirmation; defaults to `ConfirmationStrategy.Combo`.
-	 * @param props.additionalTxSenderCallbacks - Callbacks that actually submit the transaction (e.g. to a relay/bundler); required for this sender to do anything, since it never calls `sendRawTransaction` on `connection` itself. Defaults to an empty array (transaction is never actually broadcast anywhere).
-	 * @param props.txHandler - Custom `TxHandler` for signing/building transactions.
-	 * @param props.trackTxLandRate - Enables land-rate tracking.
-	 * @param props.txLandRateLookbackWindowMinutes - Rolling window, in minutes, for the land-rate calculation.
-	 * @param props.landRateToFeeFunc - Custom mapping from land rate to priority-fee multiplier.
-	 * @param props.throwOnTimeoutError - Whether confirmation timeouts throw `TxSendError`; defaults to `true`.
-	 */
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		timeout = DEFAULT_TIMEOUT,
-		retrySleep = DEFAULT_RETRY,
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		additionalTxSenderCallbacks = [],
-		txHandler,
-		trackTxLandRate,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		timeout?: number;
-		retrySleep?: number;
-		confirmationStrategy?: ConfirmationStrategy;
-		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler?: TxHandler;
-		trackTxLandRate?: boolean;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			timeout,
-			additionalConnections: [],
-			confirmationStrategy,
-			additionalTxSenderCallbacks,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-		});
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.timeout = timeout;
-		this.retrySleep = retrySleep;
-		this.additionalConnections = [];
-	}
-
-	/**
-	 * Waits `retrySleep` milliseconds, exposing an early-wake `resolve` via `reference` so
-	 * `sendRawTransaction`'s stop condition can cut the wait short once the transaction confirms.
-	 * @param reference - Mutable holder `sendRawTransaction` uses to resolve this sleep early.
-	 */
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	/**
-	 * Overrides `BaseTxSender.sendToAdditionalConnections` to skip `additionalConnections`
-	 * entirely (always empty for this sender) and only invoke `additionalTxSenderCallbacks` with
-	 * the base58-encoded transaction — this is this sender's *only* transaction submission path.
-	 * @param rawTx - Serialized, signed transaction bytes.
-	 * @param _opts - Unused (kept for `BaseTxSender` override compatibility).
-	 */
-	sendToAdditionalConnections(
-		rawTx: Buffer | Uint8Array,
-		_opts: ConfirmOptions
-	): void {
-		this.additionalTxSenderCallbacks?.map((callback) => {
-			callback(bs58.encode(rawTx));
-		});
-	}
-
-	/**
-	 * "Sends" a raw transaction by repeatedly invoking `additionalTxSenderCallbacks` with it every
-	 * `retrySleep` ms (never calling `connection.sendRawTransaction`) while concurrently waiting
-	 * for confirmation via `confirmTransaction`. Re-forwarding stops as soon as confirmation
-	 * resolves (successfully or by throwing) or `timeout` elapses.
-	 * @param rawTransaction - Serialized, signed transaction bytes (must deserialize as a `VersionedTransaction`).
-	 * @param opts - Confirmation options; `opts.commitment` is used for confirmation.
-	 * @returns The signature and confirmation slot once confirmed.
-	 * @throws Whatever `confirmTransaction` throws (e.g. `TxSendError` on timeout, or the resolved on-chain error).
-	 */
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		const deserializedTx = VersionedTransaction.deserialize(rawTransaction);
-
-		const txSig = deserializedTx.signatures[0];
-		const encodedTxSig = bs58.encode(txSig);
-
-		const startTime = this.getTimestamp();
-
-		this.sendToAdditionalConnections(rawTransaction, opts);
-		this.txSigCache?.set(encodedTxSig, false);
-
-		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.sendToAdditionalConnections(rawTransaction, opts);
-				}
-			}
-		})();
-
-		let slot: number | undefined;
-		try {
-			const result = await this.confirmTransaction(
-				encodedTxSig,
-				opts.commitment
-			);
-			slot = result?.context?.slot;
-			this.txSigCache?.set(encodedTxSig, true);
-			// eslint-disable-next-line no-useless-catch
-		} catch (e) {
-			throw e;
-		} finally {
-			stopWaiting();
-		}
-
-		return { txSig: encodedTxSig, slot };
-	}
-}

package/src/tx/priorityFeeCalculator.ts

@@ -1,117 +0,0 @@
-import { ComputeBudgetProgram, TransactionInstruction } from '@solana/web3.js';
-
-/**
- * This class determines whether a priority fee needs to be included in a transaction based on
- * a recent history of timed out transactions.
- */
-export class PriorityFeeCalculator {
-	lastTxTimeoutCount: number;
-	priorityFeeTriggered: boolean;
-	lastTxTimeoutCountTriggered: number;
-	priorityFeeLatchDurationMs: number; // how long to stay in triggered state before resetting
-
-	/**
-	 * Constructor for the PriorityFeeCalculator class.
-	 * @param currentTimeMs - The current time in milliseconds.
-	 * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
-	 */
-	constructor(
-		currentTimeMs: number,
-		priorityFeeLatchDurationMs: number = 10 * 1000
-	) {
-		this.lastTxTimeoutCount = 0;
-		this.priorityFeeTriggered = false;
-		this.lastTxTimeoutCountTriggered = currentTimeMs;
-		this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
-	}
-
-	/**
-	 * Update the priority fee state based on the current time and the current timeout count.
-	 * @param currentTimeMs current time in milliseconds
-	 * @returns true if priority fee should be included in the next transaction
-	 */
-	public updatePriorityFee(
-		currentTimeMs: number,
-		txTimeoutCount: number
-	): boolean {
-		let triggerPriorityFee = false;
-
-		if (txTimeoutCount > this.lastTxTimeoutCount) {
-			this.lastTxTimeoutCount = txTimeoutCount;
-			this.lastTxTimeoutCountTriggered = currentTimeMs;
-			triggerPriorityFee = true;
-		} else {
-			if (!this.priorityFeeTriggered) {
-				triggerPriorityFee = false;
-			} else if (
-				currentTimeMs - this.lastTxTimeoutCountTriggered <
-				this.priorityFeeLatchDurationMs
-			) {
-				triggerPriorityFee = true;
-			}
-		}
-
-		this.priorityFeeTriggered = triggerPriorityFee;
-
-		return triggerPriorityFee;
-	}
-
-	/**
-	 * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
-	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
-	 * @returns An array of transaction instructions.
-	 */
-	public generateComputeBudgetIxs(
-		computeUnitLimit: number
-	): Array<TransactionInstruction> {
-		const ixs = [
-			ComputeBudgetProgram.setComputeUnitLimit({
-				units: computeUnitLimit,
-			}),
-		];
-
-		return ixs;
-	}
-
-	/**
-	 * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
-	 * @param computeUnitLimit desired CU to use
-	 * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
-	 * @returns the compute unit price to use, in micro lamports
-	 */
-	public calculateComputeUnitPrice(
-		computeUnitLimit: number,
-		additionalFeeMicroLamports: number
-	): number {
-		return additionalFeeMicroLamports / computeUnitLimit;
-	}
-
-	/**
-	 * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
-	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
-	 * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered`.
-	 * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
-	 * @returns An array of transaction instructions.
-	 */
-	public generateComputeBudgetWithPriorityFeeIx(
-		computeUnitLimit: number,
-		usePriorityFee: boolean,
-		additionalFeeMicroLamports: number
-	): Array<TransactionInstruction> {
-		const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
-
-		if (usePriorityFee) {
-			const computeUnitPrice = this.calculateComputeUnitPrice(
-				computeUnitLimit,
-				additionalFeeMicroLamports
-			);
-			ixs.push(
-				ComputeBudgetProgram.setComputeUnitPrice({
-					microLamports: computeUnitPrice,
-				})
-			);
-		}
-
-		return ixs;
-	}
-}