@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/tx/txParamProcessor.ts

@@ -1,178 +0,0 @@
-import {
-	Connection,
-	RpcResponseAndContext,
-	SimulatedTransactionResponse,
-	VersionedTransaction,
-} from '@solana/web3.js';
-import { BaseTxParams, ProcessingTxParams } from '../types';
-
-const COMPUTE_UNIT_BUFFER_FACTOR = 1.2;
-const MAX_COMPUTE_UNITS = 1_400_000;
-
-const TEST_SIMS_ALWAYS_FAIL = false;
-
-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 TransactionParamProcessor {
-	private static async getComputeUnitsFromSim(
-		txSim: RpcResponseAndContext<SimulatedTransactionResponse>
-	) {
-		if (txSim?.value?.unitsConsumed) {
-			return txSim?.value?.unitsConsumed;
-		}
-
-		return undefined;
-	}
-
-	public static async getTxSimComputeUnits(
-		tx: VersionedTransaction,
-		connection: Connection,
-		bufferMultiplier: number, // Making this a mandatory param to force the user to remember that simulated CU's can be inaccurate and a buffer should be applied
-		lowerBoundCu?: number,
-		simulatedTx?: SimulatedTransactionResponse
-	): Promise<
-		| { success: true; computeUnits: number }
-		| { success: false; computeUnits: undefined }
-	> {
-		try {
-			if (TEST_SIMS_ALWAYS_FAIL)
-				throw new Error('Test Error::SIMS_ALWAYS_FAIL');
-
-			const simTxResult = simulatedTx
-				? ({
-						value: simulatedTx,
-				  } as RpcResponseAndContext<SimulatedTransactionResponse>)
-				: await connection.simulateTransaction(tx, {
-						replaceRecentBlockhash: true, // This is important to ensure that the blockhash is not too new.. Otherwise we will very often receive a "blockHashNotFound" error
-				  });
-
-			if (simTxResult?.value?.err) {
-				throw simTxResult?.value?.err;
-			}
-
-			const computeUnits = await this.getComputeUnitsFromSim(simTxResult);
-
-			if (computeUnits === undefined) {
-				throw new Error(
-					'TransactionParamProcessor: simulation did not return units consumed'
-				);
-			}
-
-			// Apply the buffer, but round down to the MAX_COMPUTE_UNITS, and round up to the nearest whole number
-			let bufferedComputeUnits = Math.ceil(
-				Math.min(computeUnits * bufferMultiplier, MAX_COMPUTE_UNITS)
-			);
-
-			// If a lower bound CU is passed then enforce it
-			if (lowerBoundCu) {
-				bufferedComputeUnits = Math.max(
-					bufferedComputeUnits,
-					Math.min(lowerBoundCu, MAX_COMPUTE_UNITS)
-				);
-			}
-
-			return {
-				success: true as const,
-				computeUnits: bufferedComputeUnits,
-			};
-		} catch (e) {
-			console.warn(
-				`Failed to get Simulated Compute Units for txParamProcessor`,
-				e
-			);
-
-			return {
-				success: false as const,
-				computeUnits: undefined,
-			};
-		}
-	}
-
-	static async process(props: {
-		baseTxParams: BaseTxParams;
-		processConfig: ProcessingTxParams;
-		processParams: {
-			connection: Connection;
-			simulatedTx?: SimulatedTransactionResponse;
-		};
-		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.baseTxParams;
-		}
-
-		// # Setup
-		const {
-			txBuilder: txBuilder,
-			processConfig,
-			processParams: processProps,
-		} = props;
-
-		const finalTxParams: BaseTxParams = {
-			...props.baseTxParams,
-		};
-
-		// # Run Processes
-		if (processConfig.useSimulatedComputeUnits) {
-			const txToSim = await txBuilder({
-				txParams: { ...finalTxParams, computeUnits: MAX_COMPUTE_UNITS },
-			});
-
-			const txSimComputeUnitsResult = await this.getTxSimComputeUnits(
-				txToSim,
-				processProps.connection,
-				processConfig?.computeUnitsBufferMultiplier ??
-					COMPUTE_UNIT_BUFFER_FACTOR,
-				undefined,
-				processProps.simulatedTx
-			);
-
-			if (txSimComputeUnitsResult.success) {
-				// Adjust the transaction based on the simulated compute units
-				finalTxParams.computeUnits = txSimComputeUnitsResult.computeUnits;
-			}
-		}
-
-		if (processConfig?.useSimulatedComputeUnitsForCUPriceCalculation) {
-			if (!processConfig?.useSimulatedComputeUnits) {
-				throw new Error(
-					`encountered useSimulatedComputeUnitsForFees=true, but useSimulatedComputeUnits is false`
-				);
-			}
-			if (!processConfig?.getCUPriceFromComputeUnits) {
-				throw new Error(
-					`encountered useSimulatedComputeUnitsForFees=true, but getComputeUnitPriceFromUnitsToUse helper method is undefined`
-				);
-			}
-
-			const simulatedComputeUnits = finalTxParams.computeUnits;
-
-			if (simulatedComputeUnits === undefined) {
-				throw new Error(
-					`encountered useSimulatedComputeUnitsForFees=true, but simulated compute units are unavailable (simulation likely failed)`
-				);
-			}
-
-			const computeUnitPrice = processConfig.getCUPriceFromComputeUnits(
-				simulatedComputeUnits
-			);
-
-			console.debug(
-				`🔧:: Adjusting compute unit price for simulated compute unit budget :: ${finalTxParams.computeUnitsPrice}=>${computeUnitPrice}`
-			);
-
-			finalTxParams.computeUnitsPrice = computeUnitPrice;
-		}
-
-		// # Return Final Tx Params
-		return finalTxParams;
-	}
-}

package/src/tx/types.ts

@@ -1,71 +0,0 @@
-import {
-	AddressLookupTableAccount,
-	BlockhashWithExpiryBlockHeight,
-	ConfirmOptions,
-	Signer,
-	Transaction,
-	TransactionInstruction,
-	TransactionSignature,
-	VersionedTransaction,
-} from '@solana/web3.js';
-import { IWallet } from '../types';
-
-export enum ConfirmationStrategy {
-	WebSocket = 'websocket',
-	Polling = 'polling',
-	Combo = 'combo',
-}
-
-export type TxSigAndSlot = {
-	txSig: TransactionSignature;
-	slot: number | undefined;
-};
-
-export interface TxSender {
-	wallet: IWallet;
-
-	send(
-		tx: Transaction,
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		preSigned?: boolean
-	): Promise<TxSigAndSlot>;
-
-	sendVersionedTransaction(
-		tx: VersionedTransaction,
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		preSigned?: boolean
-	): Promise<TxSigAndSlot>;
-
-	getVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		blockhash?: BlockhashWithExpiryBlockHeight
-	): Promise<VersionedTransaction>;
-
-	sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot>;
-
-	simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
-
-	getTimeoutCount(): number;
-	getSuggestedPriorityFeeMultiplier(): number;
-	getTxLandRate(): 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/utils.ts

@@ -1,107 +0,0 @@
-import {
-	AddressLookupTableAccount,
-	Transaction,
-	TransactionInstruction,
-	VersionedTransaction,
-} from '@solana/web3.js';
-
-export const MAX_TX_BYTE_SIZE = 1232;
-export const NATIVE_INSTRUCTION_MAGIC_BYTES = [0xff, 0xff, 0xff, 0xff];
-
-export const isVersionedTransaction = (
-	tx: Transaction | VersionedTransaction
-): boolean => {
-	const version = (tx as VersionedTransaction)?.version;
-	const isVersionedTx =
-		tx instanceof VersionedTransaction || version !== undefined;
-
-	return isVersionedTx;
-};
-
-export const getSizeOfTransaction = (
-	instructions: TransactionInstruction[],
-	versionedTransaction = true,
-	addressLookupTables: AddressLookupTableAccount[] = []
-): number => {
-	const programs = new Set<string>();
-	const signers = new Set<string>();
-	let accounts = new Set<string>();
-
-	instructions.forEach((ix) => {
-		try {
-			if (ix.programId) {
-				programs.add(ix.programId.toBase58());
-				accounts.add(ix.programId.toBase58());
-			}
-			if (ix.keys) {
-				ix.keys.forEach((key) => {
-					if (key.isSigner) {
-						signers.add(key.pubkey.toBase58());
-					}
-					accounts.add(key.pubkey.toBase58());
-				});
-			}
-		} catch (e) {
-			console.log(e);
-		}
-	});
-
-	const instructionSizes: number = instructions
-		.map(
-			(ix) =>
-				1 +
-				getSizeOfCompressedU16(ix.keys.length) +
-				ix.keys.length +
-				getSizeOfCompressedU16(ix.data.length) +
-				ix.data.length
-		)
-		.reduce((a, b) => a + b, 0);
-
-	let numberOfAddressLookups = 0;
-	// Filter out null/undefined lookup tables before accessing .state
-	const validLookupTables = addressLookupTables.filter(
-		(table): table is AddressLookupTableAccount =>
-			table !== null && table !== undefined
-	);
-	if (validLookupTables.length > 0) {
-		const lookupTableAddresses = validLookupTables
-			.map((addressLookupTable) =>
-				addressLookupTable.state.addresses.map((address) => address.toBase58())
-			)
-			.flat();
-		const totalNumberOfAccounts = accounts.size;
-		accounts = new Set(
-			[...accounts].filter((account) => !lookupTableAddresses.includes(account))
-		);
-		accounts = new Set([...accounts, ...programs, ...signers]);
-		numberOfAddressLookups = totalNumberOfAccounts - accounts.size;
-	}
-
-	return (
-		getSizeOfCompressedU16(signers.size) +
-		signers.size * 64 + // array of signatures
-		3 +
-		getSizeOfCompressedU16(accounts.size) +
-		32 * accounts.size + // array of account addresses
-		32 + // recent blockhash
-		getSizeOfCompressedU16(instructions.length) +
-		instructionSizes + // array of instructions
-		(versionedTransaction ? 1 + getSizeOfCompressedU16(0) : 0) +
-		(versionedTransaction ? 32 * addressLookupTables.length : 0) +
-		(versionedTransaction && addressLookupTables.length > 0 ? 2 : 0) +
-		numberOfAddressLookups
-	);
-};
-
-function getSizeOfCompressedU16(n: number) {
-	return 1 + Number(n >= 128) + Number(n >= 16384);
-}
-
-export function createNativeInstructionDiscriminatorBuffer(
-	discriminator: number
-): Uint8Array {
-	const buffer = new Uint8Array(5);
-	buffer.set(NATIVE_INSTRUCTION_MAGIC_BYTES, 0);
-	buffer.set([discriminator], 4);
-	return buffer;
-}

package/src/tx/whileValidTxSender.ts

@@ -1,295 +0,0 @@
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	Connection,
-	SendTransactionError,
-	Signer,
-	Transaction,
-	VersionedTransaction,
-} from '@solana/web3.js';
-import { BaseTxSender } from './baseTxSender';
-import bs58 from 'bs58';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-const DEFAULT_RETRY = 2000;
-
-type ResolveReference = {
-	resolve?: () => void;
-};
-
-export class WhileValidTxSender extends BaseTxSender {
-	retrySleep: number;
-	timoutCount = 0;
-	untilValid = new Map<
-		string,
-		{ blockhash: string; lastValidBlockHeight: number }
-	>();
-
-	useBlockHeightOffset = true;
-
-	private async checkAndSetUseBlockHeightOffset() {
-		this.connection.getVersion().then((version) => {
-			const solanaCoreVersion = version['solana-core'];
-
-			if (!solanaCoreVersion) return;
-
-			const majorVersion = solanaCoreVersion.split('.')[0];
-
-			if (!majorVersion) return;
-
-			const parsedMajorVersion = parseInt(majorVersion);
-
-			if (isNaN(parsedMajorVersion)) return;
-
-			if (parsedMajorVersion >= 2) {
-				this.useBlockHeightOffset = false;
-			} else {
-				this.useBlockHeightOffset = true;
-			}
-		});
-	}
-
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		retrySleep = DEFAULT_RETRY,
-		additionalConnections = new Array<Connection>(),
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		additionalTxSenderCallbacks = [],
-		txHandler,
-		trackTxLandRate,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-		throwOnTransactionError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		retrySleep?: number;
-		additionalConnections?: Connection[];
-		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		confirmationStrategy?: ConfirmationStrategy;
-		txHandler?: TxHandler;
-		trackTxLandRate?: boolean;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-		throwOnTransactionError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			additionalConnections,
-			additionalTxSenderCallbacks,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			confirmationStrategy,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-			throwOnTransactionError,
-		});
-		this.retrySleep = retrySleep;
-
-		this.checkAndSetUseBlockHeightOffset();
-	}
-
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	async prepareTx(
-		tx: Transaction,
-		additionalSigners: Array<Signer>,
-		opts: ConfirmOptions,
-		preSigned?: boolean
-	): Promise<Transaction> {
-		let latestBlockhash =
-			await this.txHandler.getLatestBlockhashForTransaction();
-
-		if (!latestBlockhash) {
-			throw new Error(
-				'WhileValidTxSender: failed to fetch latest blockhash for transaction'
-			);
-		}
-
-		// handle tx
-		let signedTx = tx;
-		if (!preSigned) {
-			signedTx = await this.txHandler.prepareTx(
-				tx,
-				additionalSigners,
-				undefined,
-				opts,
-				false,
-				latestBlockhash
-			);
-		}
-
-		// See SIGNATURE_BLOCK_AND_EXPIRY explanation in txHandler.ts if this is confusing
-		// @ts-ignore
-		if (preSigned && tx.SIGNATURE_BLOCK_AND_EXPIRY) {
-			// @ts-ignore
-			latestBlockhash = tx.SIGNATURE_BLOCK_AND_EXPIRY;
-		}
-
-		// handle subclass-specific side effects
-		const signature = signedTx?.signature || signedTx.signatures[0]?.signature;
-		if (!signature) {
-			throw new Error(
-				'WhileValidTxSender: signed transaction is missing a signature'
-			);
-		}
-		const txSig = bs58.encode(signature);
-		if (!latestBlockhash) {
-			throw new Error(
-				'WhileValidTxSender: failed to resolve latest blockhash for transaction'
-			);
-		}
-		this.untilValid.set(txSig, latestBlockhash);
-
-		return signedTx;
-	}
-
-	async sendVersionedTransaction(
-		tx: VersionedTransaction,
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions,
-		preSigned?: boolean
-	): Promise<TxSigAndSlot> {
-		let latestBlockhash =
-			await this.txHandler.getLatestBlockhashForTransaction();
-
-		if (!latestBlockhash) {
-			throw new Error(
-				'WhileValidTxSender: failed to fetch latest blockhash for transaction'
-			);
-		}
-
-		let signedTx;
-		if (preSigned) {
-			signedTx = tx;
-
-			// See SIGNATURE_BLOCK_AND_EXPIRY explanation in txHandler.ts if this is confusing
-			// @ts-ignore
-			if (tx.SIGNATURE_BLOCK_AND_EXPIRY) {
-				// @ts-ignore
-				latestBlockhash = tx.SIGNATURE_BLOCK_AND_EXPIRY;
-			}
-
-			// @ts-ignore
-		} else if (this.wallet.payer) {
-			tx.message.recentBlockhash = latestBlockhash.blockhash;
-			// @ts-ignore
-			tx.sign((additionalSigners ?? []).concat(this.wallet.payer));
-			signedTx = tx;
-		} else {
-			tx.message.recentBlockhash = latestBlockhash.blockhash;
-			additionalSigners
-				?.filter((s): s is Signer => s !== undefined)
-				.forEach((kp) => {
-					tx.sign([kp]);
-				});
-			signedTx = await this.txHandler.signVersionedTx(
-				tx,
-				additionalSigners ?? [],
-				latestBlockhash
-			);
-		}
-
-		if (opts === undefined) {
-			opts = this.opts;
-		}
-
-		const signature = signedTx.signatures[0];
-		if (!signature) {
-			throw new Error(
-				'WhileValidTxSender: signed transaction is missing a signature'
-			);
-		}
-		const txSig = bs58.encode(signature);
-		if (!latestBlockhash) {
-			throw new Error(
-				'WhileValidTxSender: failed to resolve latest blockhash for transaction'
-			);
-		}
-		this.untilValid.set(txSig, latestBlockhash);
-
-		return this.sendRawTransaction(signedTx.serialize(), opts);
-	}
-
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		const startTime = this.getTimestamp();
-
-		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-		this.txSigCache?.set(txid, false);
-		this.sendToAdditionalConnections(rawTransaction, opts);
-
-		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.connection
-						.sendRawTransaction(rawTransaction, opts)
-						.catch((e) => {
-							console.error(e);
-							stopWaiting();
-						});
-					this.sendToAdditionalConnections(rawTransaction, opts);
-				}
-			}
-		})();
-
-		let slot: number | undefined;
-		try {
-			const result = await this.confirmTransaction(txid, opts.commitment);
-
-			this.txSigCache?.set(txid, true);
-
-			if (result) {
-				await this.checkConfirmationResultForError(txid, result.value);
-
-				if (result.value?.err && this.throwOnTransactionError) {
-					// Fallback error handling if there's a problem reporting the error in checkConfirmationResultForError
-					throw new SendTransactionError({
-						action: 'send',
-						signature: txid,
-						transactionMessage: `Transaction Failed`,
-					});
-				}
-
-				slot = result.context.slot;
-			}
-			// eslint-disable-next-line no-useless-catch
-		} catch (e) {
-			throw e;
-		} finally {
-			stopWaiting();
-			this.untilValid.delete(txid);
-		}
-
-		return { txSig: txid, slot };
-	}
-}