@velocity-exchange/sdk 0.1.0 → 0.2.0

package/src/swift/swiftOrderSubscriber.ts

@@ -74,7 +74,7 @@ export class SwiftOrderSubscriber {
 	private ws: WebSocket | null = null;
 	private velocityClient: VelocityClient;
 	public userAccountGetter?: AccountGetter; // In practice, this for now is just an OrderSubscriber or a UserMap
-	public onOrder: (
+	public onOrder?: (
 		orderMessageRaw: SwiftOrderMessage,
 		signedMessage:
 			| SignedMsgOrderParamsMessage
@@ -92,8 +92,8 @@ export class SwiftOrderSubscriber {
 
 	unsubscribe() {
 		if (this.subscribed) {
-			this.ws.removeAllListeners();
-			this.ws.terminate();
+			this.ws?.removeAllListeners();
+			this.ws?.terminate();
 			this.ws = null;
 			this.subscribed = false;
 		}
@@ -245,11 +245,8 @@ export class SwiftOrderSubscriber {
 			}, 5000);
 		});
 
-		ws.on('error', async (request, response) => {
-			console.error(
-				'WS closed from error, reconnecting in 1s:',
-				response.statusCode
-			);
+		ws.on('error', async (error: Error) => {
+			console.error('WS closed from error, reconnecting in 1s:', error);
 			setTimeout(() => {
 				if (this.heartbeatTimeout) clearTimeout(this.heartbeatTimeout);
 				this.reconnect();
@@ -343,8 +340,12 @@ export class SwiftOrderSubscriber {
 		}
 
 		console.log('Reconnecting to WebSocket...');
+		const onOrder = this.onOrder;
+		if (!onOrder) {
+			throw new Error('onOrder callback function must be set');
+		}
 		setTimeout(() => {
-			this.subscribe(this.onOrder);
+			this.subscribe(onOrder);
 		}, 1000);
 	}
 }

package/src/testClient.ts

@@ -7,7 +7,7 @@ import { VelocityClientConfig } from './velocityClientConfig';
 export class TestClient extends AdminClient {
 	public constructor(config: VelocityClientConfig) {
 		config.txVersion = 'legacy';
-		if (config.accountSubscription.type !== 'polling') {
+		if (config.accountSubscription?.type !== 'polling') {
 			throw new Error('Test client must be polling');
 		}
 		super(config);
@@ -30,7 +30,7 @@ export class TestClient extends AdminClient {
 			this.accountSubscriber as PollingVelocityClientAccountSubscriber
 		).accountLoader.mostRecentSlot;
 		await this.fetchAccounts();
-		while (lastFetchedSlot < slot) {
+		while (slot !== undefined && lastFetchedSlot < slot) {
 			await this.fetchAccounts();
 			lastFetchedSlot = (
 				this.accountSubscriber as PollingVelocityClientAccountSubscriber

package/src/tokenFaucet.ts

@@ -101,6 +101,11 @@ export class TokenFaucet {
 			},
 		});
 		const tx = new Transaction().add(ix);
+		if (!this.context) {
+			throw new Error(
+				'TokenFaucet: initialize() requires a BankrunContextWrapper context'
+			);
+		}
 		const txSig = await this.context.sendTransaction(tx);
 		return txSig;
 	}
@@ -134,6 +139,11 @@ export class TokenFaucet {
 		if (this.context) {
 			return await this.context.sendTransaction(tx);
 		} else {
+			if (!this.program.provider.sendAndConfirm) {
+				throw new Error(
+					'TokenFaucet: program provider does not support sendAndConfirm'
+				);
+			}
 			return await this.program.provider.sendAndConfirm(tx, [], this.opts);
 		}
 	}
@@ -180,8 +190,9 @@ export class TokenFaucet {
 		let associatedTokenAccountExists = false;
 
 		try {
-			const assosciatedTokenAccount =
-				await this.context.connection.getAccountInfo(associatedTokenPublicKey);
+			const assosciatedTokenAccount = this.context
+				? await this.context.connection.getAccountInfo(associatedTokenPublicKey)
+				: await this.connection.getAccountInfo(associatedTokenPublicKey);
 
 			associatedTokenAccountExists = !!assosciatedTokenAccount;
 		} catch (e) {
@@ -199,6 +210,11 @@ export class TokenFaucet {
 		if (this.context) {
 			txSig = await this.context.sendTransaction(tx);
 		} else {
+			if (!this.program.provider.sendAndConfirm) {
+				throw new Error(
+					'TokenFaucet: program provider does not support sendAndConfirm'
+				);
+			}
 			txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
 		}
 
@@ -257,7 +273,10 @@ export class TokenFaucet {
 			props.callback(await this.getTokenAccountInfo(props));
 
 			// Couldn't find a way to do it using anchor framework subscription — fall back to onAccountChange.
-			this.context.connection.onAccountChange(
+			const subscribeConnection = this.context
+				? this.context.connection
+				: this.connection;
+			subscribeConnection.onAccountChange(
 				tokenAccountKey,
 				async (
 					_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */

package/src/tx/baseTxSender.ts

@@ -40,7 +40,7 @@ export abstract class BaseTxSender implements TxSender {
 	additionalConnections: Connection[];
 	timeoutCount = 0;
 	confirmationStrategy: ConfirmationStrategy;
-	additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+	additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 	txHandler: TxHandler;
 	trackTxLandRate?: boolean;
 	throwOnTimeoutError: boolean;
@@ -72,7 +72,7 @@ export abstract class BaseTxSender implements TxSender {
 		wallet: IWallet;
 		opts?: ConfirmOptions;
 		timeout?: number;
-		additionalConnections?;
+		additionalConnections?: Connection[];
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		txHandler?: TxHandler;
@@ -181,7 +181,7 @@ export abstract class BaseTxSender implements TxSender {
 		} else {
 			signedTx = await this.txHandler.signVersionedTx(
 				tx,
-				additionalSigners,
+				additionalSigners ?? [],
 				undefined,
 				this.wallet
 			);
@@ -221,7 +221,7 @@ export abstract class BaseTxSender implements TxSender {
 	async confirmTransactionWebSocket(
 		signature: TransactionSignature,
 		commitment?: Commitment
-	): Promise<RpcResponseAndContext<SignatureResult>> {
+	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
 		let decodedSignature;
 		try {
 			decodedSignature = bs58.decode(signature);
@@ -234,11 +234,11 @@ export abstract class BaseTxSender implements TxSender {
 		const start = Date.now();
 		const subscriptionCommitment = commitment || this.opts.commitment;
 
-		const subscriptionIds = new Array<number>();
+		const subscriptionIds = new Array<number | undefined>();
 		const connections = [this.connection, ...this.additionalConnections];
 		let response: RpcResponseAndContext<SignatureResult> | null = null;
 		const promises = connections.map((connection, i) => {
-			let subscriptionId;
+			let subscriptionId: number | undefined;
 			const confirmPromise = new Promise((resolve, reject) => {
 				try {
 					subscriptionId = connection.onSignature(
@@ -301,7 +301,7 @@ export abstract class BaseTxSender implements TxSender {
 			}
 		}
 
-		return response;
+		return response ?? undefined;
 	}
 
 	async confirmTransactionPolling(
@@ -349,7 +349,7 @@ export abstract class BaseTxSender implements TxSender {
 	async confirmTransaction(
 		signature: TransactionSignature,
 		commitment?: Commitment
-	): Promise<RpcResponseAndContext<SignatureResult>> {
+	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
 		if (
 			this.confirmationStrategy === ConfirmationStrategy.WebSocket ||
 			this.confirmationStrategy === ConfirmationStrategy.Combo
@@ -431,7 +431,7 @@ export abstract class BaseTxSender implements TxSender {
 	}
 
 	public getTxLandRate(): number {
-		if (!this.trackTxLandRate) {
+		if (!this.trackTxLandRate || !this.txSigCache) {
 			return this.txLandRate;
 		}
 		const keys = this.txSigCache.keys();
@@ -453,7 +453,7 @@ export abstract class BaseTxSender implements TxSender {
 	private defaultLandRateToFeeFunc(txLandRate: number) {
 		if (
 			txLandRate >= BASELINE_TX_LAND_RATE ||
-			this.txSigCache.keys().length < 3
+			(this.txSigCache?.keys().length ?? 0) < 3
 		) {
 			return 1;
 		}

package/src/tx/fastSingleTxSender.ts

@@ -22,11 +22,11 @@ export class FastSingleTxSender extends BaseTxSender {
 	blockhashRefreshInterval: number;
 	additionalConnections: Connection[];
 	timoutCount = 0;
-	recentBlockhash: BlockhashWithExpiryBlockHeight;
+	recentBlockhash?: BlockhashWithExpiryBlockHeight;
 	skipConfirmation: boolean;
 	confirmInBackground: boolean;
 	blockhashCommitment: Commitment;
-	blockhashIntervalId: NodeJS.Timer;
+	blockhashIntervalId?: NodeJS.Timer;
 
 	public constructor({
 		connection,
@@ -50,7 +50,7 @@ export class FastSingleTxSender extends BaseTxSender {
 		opts?: ConfirmOptions;
 		timeout?: number;
 		blockhashRefreshInterval?: number;
-		additionalConnections?;
+		additionalConnections?: Connection[];
 		skipConfirmation?: boolean;
 		confirmInBackground?: boolean;
 		blockhashCommitment?: Commitment;
@@ -114,22 +114,26 @@ export class FastSingleTxSender extends BaseTxSender {
 			throw e;
 		}
 
-		let slot: number;
+		let slot: number | undefined;
 		if (!this.skipConfirmation) {
 			try {
 				if (this.confirmInBackground) {
 					this.confirmTransaction(txid, opts.commitment).then(
 						async (result) => {
 							this.txSigCache?.set(txid, true);
-							await this.checkConfirmationResultForError(txid, result?.value);
-							slot = result.context.slot;
+							if (result) {
+								await this.checkConfirmationResultForError(txid, result.value);
+								slot = result.context.slot;
+							}
 						}
 					);
 				} else {
 					const result = await this.confirmTransaction(txid, opts.commitment);
 					this.txSigCache?.set(txid, true);
-					await this.checkConfirmationResultForError(txid, result?.value);
-					slot = result?.context?.slot;
+					if (result) {
+						await this.checkConfirmationResultForError(txid, result.value);
+						slot = result.context.slot;
+					}
 				}
 			} catch (e) {
 				console.error(e);

package/src/tx/reportTransactionError.ts

@@ -29,10 +29,15 @@ const getTransactionResult = async (
 	txSig: string,
 	connection: Connection,
 	commitment?: Commitment
-): Promise<VersionedTransactionResponse> => {
-	const finality = commitmentToFinality(
-		commitment || connection.commitment || DEFAULT_CONFIRMATION_OPTS.commitment
-	);
+): Promise<VersionedTransactionResponse | null> => {
+	const resolvedCommitment =
+		commitment || connection.commitment || DEFAULT_CONFIRMATION_OPTS.commitment;
+	if (!resolvedCommitment) {
+		throw new Error(
+			'No commitment available when reporting transaction error. Provide a commitment, set one on the connection, or configure DEFAULT_CONFIRMATION_OPTS.'
+		);
+	}
+	const finality = commitmentToFinality(resolvedCommitment);
 	return await connection.getTransaction(txSig, {
 		maxSupportedTransactionVersion: 0,
 		commitment: finality,
@@ -43,7 +48,7 @@ const getTransactionResultWithRetry = async (
 	txSig: string,
 	connection: Connection,
 	commitment?: Commitment
-): Promise<VersionedTransactionResponse> => {
+): Promise<VersionedTransactionResponse | null> => {
 	const start = Date.now();
 
 	const retryTimeout = 3_000; // Timeout after 3 seconds
@@ -111,7 +116,7 @@ export const getTransactionErrorFromTxSig = async (
 	txSig: string,
 	connection: Connection,
 	commitment?: Commitment
-): Promise<SendTransactionError> => {
+): Promise<SendTransactionError | undefined> => {
 	const transactionResult = await getTransactionResultWithRetry(
 		txSig,
 		connection,
@@ -137,7 +142,7 @@ export const getTransactionErrorFromTxSig = async (
 
 export const getTransactionError = (
 	transactionResult: VersionedTransactionResponse
-): SendTransactionError => {
+): SendTransactionError | undefined => {
 	if (!transactionResult?.meta?.err) {
 		return;
 	}

package/src/tx/retryTxSender.ts

@@ -41,7 +41,7 @@ export class RetryTxSender extends BaseTxSender {
 		opts?: ConfirmOptions;
 		timeout?: number;
 		retrySleep?: number;
-		additionalConnections?;
+		additionalConnections?: Connection[];
 		confirmationStrategy?: ConfirmationStrategy;
 		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
 		txHandler?: TxHandler;
@@ -115,14 +115,16 @@ export class RetryTxSender extends BaseTxSender {
 			}
 		})();
 
-		let slot: number;
+		let slot: number | undefined;
 		try {
 			const result = await this.confirmTransaction(txid, opts.commitment);
 			this.txSigCache?.set(txid, true);
 
-			await this.checkConfirmationResultForError(txid, result?.value);
+			if (result) {
+				await this.checkConfirmationResultForError(txid, result.value);
 
-			slot = result?.context?.slot;
+				slot = result.context?.slot;
+			}
 			// eslint-disable-next-line no-useless-catch
 		} catch (e) {
 			throw e;

package/src/tx/txHandler.ts

@@ -67,7 +67,7 @@ export type TxBuildingProps = {
 	instructions: TransactionInstruction | TransactionInstruction[];
 	txVersion: TransactionVersion;
 	connection: Connection;
-	preFlightCommitment: Commitment;
+	preFlightCommitment?: Commitment;
 	fetchAllMarketLookupTableAccounts: () => Promise<AddressLookupTableAccount[]>;
 	lookupTables?: AddressLookupTableAccount[];
 	forceVersionedTransaction?: boolean;
@@ -104,7 +104,7 @@ export class TxHandler {
 	) => void;
 
 	private blockhashCommitment: Commitment =
-		DEFAULT_CONFIRMATION_OPTS.commitment;
+		DEFAULT_CONFIRMATION_OPTS.commitment ?? 'confirmed';
 	private blockHashFetcher: BlockhashFetcher;
 
 	constructor(props: {
@@ -181,6 +181,22 @@ export class TxHandler {
 		return this.blockHashFetcher.getLatestBlockhash();
 	}
 
+	/**
+	 * Resolves a usable recent blockhash, preferring a caller-provided one and
+	 * otherwise fetching the latest. Throws if no blockhash can be obtained,
+	 * since a transaction cannot be built or signed without one.
+	 */
+	private async resolveRecentBlockhash(
+		recentBlockhash?: BlockhashWithExpiryBlockHeight
+	): Promise<BlockhashWithExpiryBlockHeight> {
+		const resolved =
+			recentBlockhash ?? (await this.getLatestBlockhashForTransaction());
+		if (!resolved) {
+			throw new Error('TxHandler: failed to fetch a recent blockhash');
+		}
+		return resolved;
+	}
+
 	/**
 	 * Applies recent blockhash and signs a given transaction
 	 * @param tx
@@ -206,17 +222,17 @@ export class TxHandler {
 		[wallet, confirmationOpts] = this.getProps(wallet, confirmationOpts);
 
 		tx.feePayer = wallet.publicKey;
-		recentBlockhash = recentBlockhash
-			? recentBlockhash
-			: await this.getLatestBlockhashForTransaction();
-		tx.recentBlockhash = recentBlockhash.blockhash;
+		const resolvedBlockhash = await this.resolveRecentBlockhash(
+			recentBlockhash
+		);
+		tx.recentBlockhash = resolvedBlockhash.blockhash;
 
-		this.addHashAndExpiryToLookup(recentBlockhash);
+		this.addHashAndExpiryToLookup(resolvedBlockhash);
 
 		const signedTx = await this.signTx(tx, additionalSigners);
 
 		// @ts-ignore
-		signedTx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
+		signedTx.SIGNATURE_BLOCK_AND_EXPIRY = resolvedBlockhash;
 
 		return signedTx;
 	}
@@ -237,20 +253,30 @@ export class TxHandler {
 				Buffer.from((signedTx as VersionedTransaction).signatures[0])
 			) as string;
 		} else {
-			return bs58.encode(
-				Buffer.from((signedTx as Transaction).signature)
-			) as string;
+			const signature = (signedTx as Transaction).signature;
+			if (!signature) {
+				throw new Error(
+					'TxHandler: cannot derive txSig from an unsigned legacy transaction'
+				);
+			}
+			return bs58.encode(Buffer.from(signature)) as string;
 		}
 	}
 
 	private getBlockhashFromSignedTx(
 		signedTx: Transaction | VersionedTransaction
-	) {
-		if (this.isVersionedTransaction(signedTx)) {
-			return (signedTx as VersionedTransaction).message.recentBlockhash;
-		} else {
-			return (signedTx as Transaction).recentBlockhash;
+	): string {
+		const blockHash = this.isVersionedTransaction(signedTx)
+			? (signedTx as VersionedTransaction).message.recentBlockhash
+			: (signedTx as Transaction).recentBlockhash;
+
+		if (!blockHash) {
+			throw new Error(
+				'TxHandler: signed transaction is missing a recentBlockhash'
+			);
 		}
+
+		return blockHash;
 	}
 
 	private async signTx(
@@ -328,13 +354,13 @@ export class TxHandler {
 
 	private handleSignedTxData(
 		txData: Omit<SignedTxData, 'lastValidBlockHeight'>[]
-	) {
+	): SignedTxData[] {
 		if (!this.returnBlockHeightsWithSignedTxCallbackData) {
 			if (this.onSignedCb) {
 				this.onSignedCb(txData);
 			}
 
-			return;
+			return [];
 		}
 
 		const signedTxData = txData.map((tx) => {
@@ -377,14 +403,14 @@ export class TxHandler {
 				}) as Promise<VersionedTransaction>,
 			processConfig: {
 				useSimulatedComputeUnits:
-					txBuildingProps.txParams.useSimulatedComputeUnits,
+					txBuildingProps.txParams?.useSimulatedComputeUnits,
 				computeUnitsBufferMultiplier:
-					txBuildingProps.txParams.computeUnitsBufferMultiplier,
+					txBuildingProps.txParams?.computeUnitsBufferMultiplier,
 				useSimulatedComputeUnitsForCUPriceCalculation:
 					txBuildingProps.txParams
-						.useSimulatedComputeUnitsForCUPriceCalculation,
+						?.useSimulatedComputeUnitsForCUPriceCalculation,
 				getCUPriceFromComputeUnits:
-					txBuildingProps.txParams.getCUPriceFromComputeUnits,
+					txBuildingProps.txParams?.getCUPriceFromComputeUnits,
 			},
 			processParams: {
 				connection: this.connection,
@@ -468,8 +494,9 @@ export class TxHandler {
 			instructions: (TransactionInstruction | TransactionInstruction[])[];
 		}
 	) {
-		const recentBlockhash =
-			props?.recentBlockhash ?? (await this.getLatestBlockhashForTransaction());
+		const recentBlockhash = await this.resolveRecentBlockhash(
+			props?.recentBlockhash
+		);
 
 		return await Promise.all(
 			props.instructions.map((ix) => {
@@ -567,7 +594,11 @@ export class TxHandler {
 		// # Create Tx Instructions
 		const allIx = [];
 		const computeUnits = baseTxParams?.computeUnits;
-		if (computeUnits > 0 && !hasSetComputeUnitLimitIx) {
+		if (
+			computeUnits !== undefined &&
+			computeUnits > 0 &&
+			!hasSetComputeUnitLimitIx
+		) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitLimit({
 					units: computeUnits,
@@ -583,7 +614,11 @@ export class TxHandler {
 					microLamports: 0,
 				})
 			);
-		} else if (computeUnitsPrice > 0 && !hasSetComputeUnitPriceIx) {
+		} else if (
+			computeUnitsPrice !== undefined &&
+			computeUnitsPrice > 0 &&
+			!hasSetComputeUnitPriceIx
+		) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitPrice({
 					microLamports: computeUnitsPrice,
@@ -593,8 +628,9 @@ export class TxHandler {
 
 		allIx.push(...instructionsToUse);
 
-		const recentBlockhash =
-			props?.recentBlockhash ?? (await this.getLatestBlockhashForTransaction());
+		const recentBlockhash = await this.resolveRecentBlockhash(
+			props?.recentBlockhash
+		);
 
 		// # Create and return Transaction
 		if (txVersion === 'legacy') {
@@ -659,19 +695,19 @@ export class TxHandler {
 		commitment?: Commitment,
 		recentBlockhash?: BlockhashWithExpiryBlockHeight
 	) {
-		recentBlockhash = recentBlockhash
-			? recentBlockhash
-			: await this.getLatestBlockhashForTransaction();
+		const resolvedBlockhash = await this.resolveRecentBlockhash(
+			recentBlockhash
+		);
 
-		this.addHashAndExpiryToLookup(recentBlockhash);
+		this.addHashAndExpiryToLookup(resolvedBlockhash);
 
 		for (const tx of Object.values(txsMap)) {
 			if (!tx) continue;
-			tx.recentBlockhash = recentBlockhash.blockhash;
+			tx.recentBlockhash = resolvedBlockhash.blockhash;
 			tx.feePayer = wallet?.publicKey ?? this.wallet?.publicKey;
 
 			// @ts-ignore
-			tx.SIGNATURE_BLOCK_AND_EXPIRY = recentBlockhash;
+			tx.SIGNATURE_BLOCK_AND_EXPIRY = resolvedBlockhash;
 		}
 
 		return this.getSignedTransactionMap(txsMap, wallet);
@@ -698,12 +734,18 @@ export class TxHandler {
 		const txsToSignEntries = Object.entries(txsToSignMap);
 
 		// Create a map of the same keys as the input map, but with the values set to undefined. We'll populate the filtered (non-undefined) values with signed transactions.
-		const signedTxMap = txsToSignEntries.reduce((acc, [key]) => {
-			acc[key] = undefined;
-			return acc;
-		}, {}) as T;
+		const signedTxMap = txsToSignEntries.reduce(
+			(acc, [key]) => {
+				acc[key] = undefined;
+				return acc;
+			},
+			{} as Record<string, Transaction | VersionedTransaction | undefined>
+		) as T;
 
-		const filteredTxEntries = txsToSignEntries.filter(([_, tx]) => !!tx);
+		const filteredTxEntries = txsToSignEntries.filter(
+			(entry): entry is [string, Transaction | VersionedTransaction] =>
+				!!entry[1]
+		);
 
 		// Extra handling for legacy transactions
 		for (const [_key, tx] of filteredTxEntries) {
@@ -761,10 +803,13 @@ export class TxHandler {
 			instructions: Object.values(props.instructionsMap),
 		});
 
-		return Object.keys(props.instructionsMap).reduce((acc, key, index) => {
-			acc[key] = builtTxs[index];
-			return acc;
-		}, {}) as MappedRecord<T, Transaction | VersionedTransaction>;
+		return Object.keys(props.instructionsMap).reduce(
+			(acc, key, index) => {
+				acc[key] = builtTxs[index];
+				return acc;
+			},
+			{} as Record<string, Transaction | VersionedTransaction | undefined>
+		) as MappedRecord<T, Transaction | VersionedTransaction>;
 	}
 
 	/**

package/src/tx/txParamProcessor.ts

@@ -35,7 +35,10 @@ export class TransactionParamProcessor {
 		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: boolean; computeUnits: number }> {
+	): Promise<
+		| { success: true; computeUnits: number }
+		| { success: false; computeUnits: undefined }
+	> {
 		try {
 			if (TEST_SIMS_ALWAYS_FAIL)
 				throw new Error('Test Error::SIMS_ALWAYS_FAIL');
@@ -54,6 +57,12 @@ export class TransactionParamProcessor {
 
 			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)
@@ -68,7 +77,7 @@ export class TransactionParamProcessor {
 			}
 
 			return {
-				success: true,
+				success: true as const,
 				computeUnits: bufferedComputeUnits,
 			};
 		} catch (e) {
@@ -78,7 +87,7 @@ export class TransactionParamProcessor {
 			);
 
 			return {
-				success: false,
+				success: false as const,
 				computeUnits: undefined,
 			};
 		}
@@ -146,6 +155,12 @@ export class TransactionParamProcessor {
 
 			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
 			);

package/src/tx/types.ts

@@ -18,7 +18,7 @@ export enum ConfirmationStrategy {
 
 export type TxSigAndSlot = {
 	txSig: TransactionSignature;
-	slot: number;
+	slot: number | undefined;
 };
 
 export interface TxSender {