Replace transaction with transactionMessage where the latter term was used incorrectly

steveluscher · steveluscher · commit d50c9ebfc514 · 2025-04-14T21:43:58.000Z
diff --git a/packages/transaction-messages/README.md b/packages/transaction-messages/README.md
@@ -24,11 +24,11 @@ import {
     setTransactionMessageLifetimeUsingBlockhash,
 } from '@solana/transaction-messages';
 
-const transferTransaction = pipe(
+const transferTransactionMessage = pipe(
     createTransactionMessage({ version: 0 }),
-    tx => setTransactionMessageFeePayer(myAddress, tx),
-    tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
-    tx => appendTransactionMessageInstruction(getTransferSolInstruction({ source, destination, amount }), tx),
+    m => setTransactionMessageFeePayer(myAddress, m),
+    m => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+    m => appendTransactionMessageInstruction(getTransferSolInstruction({ source, destination, amount }), m),
 );
 ```
 
@@ -49,7 +49,7 @@ Given a `TransactionVersion` this method will return an empty transaction having
 ```ts
 import { createTransactionMessage } from '@solana/transaction-messages';
 
-const tx = createTransactionMessage({ version: 0 });
+const message = createTransactionMessage({ version: 0 });
 ```
 
 ## Setting the fee payer
@@ -111,7 +111,7 @@ Given a blockhash and the last block height at which that blockhash is considere
 import { setTransactionMessageLifetimeUsingBlockhash } from '@solana/transaction-messages';
 
 const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
-const txWithBlockhashLifetime = setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx);
+const txMessageWithBlockhashLifetime = setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, txMessage);
 ```
 
 #### `setTransactionMessageLifetimeUsingDurableNonce()`
@@ -164,7 +164,7 @@ function handleSubmit() {
         // Typescript will upcast `blockhash` to `Blockhash`.
         assertIsBlockhash(blockhash);
         // At this point, `blockhash` is a `Blockhash` that can be used with the RPC.
-        const blockhashIsValid = await rpc.isBlockhashValid(blockhash).send();
+        const { value: blockhashIsValid } = await rpc.isBlockhashValid(blockhash).send();
     } catch (e) {
         // `blockhash` turned out not to be a base58-encoded blockhash
     }
diff --git a/packages/transaction-messages/src/__typetests__/transaction-message-typetests.ts b/packages/transaction-messages/src/__typetests__/transaction-message-typetests.ts
@@ -65,29 +65,29 @@ setTransactionMessageLifetimeUsingBlockhash(
 
 {
     // assertIsTransactionMessageWithBlockhashLifetime
-    const transaction = null as unknown as BaseTransactionMessage;
+    const transactionMessage = null as unknown as BaseTransactionMessage;
     // @ts-expect-error Should not be blockhash lifetime
-    transaction satisfies TransactionMessageWithBlockhashLifetime;
+    transactionMessage satisfies TransactionMessageWithBlockhashLifetime;
     // @ts-expect-error Should not satisfy has blockhash
-    transaction satisfies {
+    transactionMessage satisfies {
         lifetimeConstraint: {
             blockhash: Blockhash;
         };
     };
     // @ts-expect-error Should not satisfy has lastValidBlockHeight
-    transaction satisfies {
+    transactionMessage satisfies {
         lifetimeConstraint: {
             lastValidBlockHeight: bigint;
         };
     };
-    assertIsTransactionMessageWithBlockhashLifetime(transaction);
-    transaction satisfies TransactionMessageWithBlockhashLifetime;
-    transaction satisfies {
+    assertIsTransactionMessageWithBlockhashLifetime(transactionMessage);
+    transactionMessage satisfies TransactionMessageWithBlockhashLifetime;
+    transactionMessage satisfies {
         lifetimeConstraint: {
             blockhash: Blockhash;
         };
     };
-    transaction satisfies {
+    transactionMessage satisfies {
         lifetimeConstraint: {
             lastValidBlockHeight: bigint;
         };
@@ -233,9 +233,9 @@ null as unknown as BaseTransactionMessage &
     // @ts-expect-error missing fee payer
     TransactionMessageWithBlockhashLifetime satisfies CompilableTransactionMessage;
 {
-    const transaction = null as unknown as BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime;
+    const transactionMessage = null as unknown as BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime;
     // @ts-expect-error missing fee payer
-    transaction satisfies CompilableTransactionMessage;
+    transactionMessage satisfies CompilableTransactionMessage;
 }
 null as unknown as BaseTransactionMessage &
     ITransactionMessageWithFeePayer &
diff --git a/packages/transaction-messages/src/blockhash.ts b/packages/transaction-messages/src/blockhash.ts
@@ -14,56 +14,58 @@ export interface TransactionMessageWithBlockhashLifetime {
 }
 
 export function isTransactionMessageWithBlockhashLifetime(
-    transaction: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
-): transaction is BaseTransactionMessage & TransactionMessageWithBlockhashLifetime {
+    transactionMessage: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
+): transactionMessage is BaseTransactionMessage & TransactionMessageWithBlockhashLifetime {
     const lifetimeConstraintShapeMatches =
-        'lifetimeConstraint' in transaction &&
-        typeof transaction.lifetimeConstraint.blockhash === 'string' &&
-        typeof transaction.lifetimeConstraint.lastValidBlockHeight === 'bigint';
+        'lifetimeConstraint' in transactionMessage &&
+        typeof transactionMessage.lifetimeConstraint.blockhash === 'string' &&
+        typeof transactionMessage.lifetimeConstraint.lastValidBlockHeight === 'bigint';
     if (!lifetimeConstraintShapeMatches) return false;
     try {
-        assertIsBlockhash(transaction.lifetimeConstraint.blockhash);
+        assertIsBlockhash(transactionMessage.lifetimeConstraint.blockhash);
         return true;
     } catch {
         return false;
     }
 }
 
 export function assertIsTransactionMessageWithBlockhashLifetime(
-    transaction: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
-): asserts transaction is BaseTransactionMessage & TransactionMessageWithBlockhashLifetime {
-    if (!isTransactionMessageWithBlockhashLifetime(transaction)) {
+    transactionMessage: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
+): asserts transactionMessage is BaseTransactionMessage & TransactionMessageWithBlockhashLifetime {
+    if (!isTransactionMessageWithBlockhashLifetime(transactionMessage)) {
         throw new SolanaError(SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME);
     }
 }
 
 export function setTransactionMessageLifetimeUsingBlockhash<
-    TTransaction extends BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime,
+    TTransactionMessage extends BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime,
 >(
     blockhashLifetimeConstraint: BlockhashLifetimeConstraint,
-    transaction: TTransaction,
-): Omit<TTransaction, 'lifetimeConstraint'> & TransactionMessageWithBlockhashLifetime;
+    transactionMessage: TTransactionMessage,
+): Omit<TTransactionMessage, 'lifetimeConstraint'> & TransactionMessageWithBlockhashLifetime;
 
 export function setTransactionMessageLifetimeUsingBlockhash<
-    TTransaction extends BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
+    TTransactionMessage extends
+        | BaseTransactionMessage
+        | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
 >(
     blockhashLifetimeConstraint: BlockhashLifetimeConstraint,
-    transaction: TTransaction,
-): TransactionMessageWithBlockhashLifetime & TTransaction;
+    transactionMessage: TTransactionMessage,
+): TransactionMessageWithBlockhashLifetime & TTransactionMessage;
 
 export function setTransactionMessageLifetimeUsingBlockhash(
     blockhashLifetimeConstraint: BlockhashLifetimeConstraint,
-    transaction: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
+    transactionMessage: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithBlockhashLifetime),
 ) {
     if (
-        'lifetimeConstraint' in transaction &&
-        transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash &&
-        transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight
+        'lifetimeConstraint' in transactionMessage &&
+        transactionMessage.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash &&
+        transactionMessage.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight
     ) {
-        return transaction;
+        return transactionMessage;
     }
     const out = {
-        ...transaction,
+        ...transactionMessage,
         lifetimeConstraint: Object.freeze(blockhashLifetimeConstraint),
     };
     Object.freeze(out);
diff --git a/packages/transaction-messages/src/compile/message.ts b/packages/transaction-messages/src/compile/message.ts
@@ -27,22 +27,27 @@ type VersionedCompiledTransactionMessage = BaseCompiledTransactionMessage &
     }>;
 
 export function compileTransactionMessage(
-    transaction: CompilableTransactionMessage & Readonly<{ version: 'legacy' }>,
+    transactionMessage: CompilableTransactionMessage & Readonly<{ version: 'legacy' }>,
 ): LegacyCompiledTransactionMessage;
 export function compileTransactionMessage(
-    transaction: CompilableTransactionMessage,
+    transactionMessage: CompilableTransactionMessage,
 ): VersionedCompiledTransactionMessage;
-export function compileTransactionMessage(transaction: CompilableTransactionMessage): CompiledTransactionMessage {
-    const addressMap = getAddressMapFromInstructions(transaction.feePayer.address, transaction.instructions);
+export function compileTransactionMessage(
+    transactionMessage: CompilableTransactionMessage,
+): CompiledTransactionMessage {
+    const addressMap = getAddressMapFromInstructions(
+        transactionMessage.feePayer.address,
+        transactionMessage.instructions,
+    );
     const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
     return {
-        ...(transaction.version !== 'legacy'
+        ...(transactionMessage.version !== 'legacy'
             ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) }
             : null),
         header: getCompiledMessageHeader(orderedAccounts),
-        instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
-        lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
+        instructions: getCompiledInstructions(transactionMessage.instructions, orderedAccounts),
+        lifetimeToken: getCompiledLifetimeToken(transactionMessage.lifetimeConstraint),
         staticAccounts: getCompiledStaticAccounts(orderedAccounts),
-        version: transaction.version,
+        version: transactionMessage.version,
     };
 }
diff --git a/packages/transaction-messages/src/decompile-message.ts b/packages/transaction-messages/src/decompile-message.ts
@@ -219,14 +219,14 @@ export function decompileTransactionMessage(
 
     return pipe(
         createTransactionMessage({ version: compiledTransactionMessage.version as TransactionVersion }),
-        tx => setTransactionMessageFeePayer(feePayer, tx),
-        tx =>
+        m => setTransactionMessageFeePayer(feePayer, m),
+        m =>
             instructions.reduce((acc, instruction) => {
                 return appendTransactionMessageInstruction(instruction, acc);
-            }, tx),
-        tx =>
+            }, m),
+        m =>
             'blockhash' in lifetimeConstraint
-                ? setTransactionMessageLifetimeUsingBlockhash(lifetimeConstraint, tx)
-                : setTransactionMessageLifetimeUsingDurableNonce(lifetimeConstraint, tx),
+                ? setTransactionMessageLifetimeUsingBlockhash(lifetimeConstraint, m)
+                : setTransactionMessageLifetimeUsingDurableNonce(lifetimeConstraint, m),
     );
 }
diff --git a/packages/transaction-messages/src/durable-nonce.ts b/packages/transaction-messages/src/durable-nonce.ts
@@ -62,9 +62,9 @@ export interface TransactionMessageWithDurableNonceLifetime<
 }
 
 export function assertIsDurableNonceTransactionMessage(
-    transaction: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime),
-): asserts transaction is BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime {
-    if (!isDurableNonceTransaction(transaction)) {
+    transactionMessage: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime),
+): asserts transactionMessage is BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime {
+    if (!isDurableNonceTransaction(transactionMessage)) {
         throw new SolanaError(SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME);
     }
 }
@@ -118,13 +118,13 @@ function isAdvanceNonceAccountInstructionData(data: ReadonlyUint8Array): data is
 }
 
 export function isDurableNonceTransaction(
-    transaction: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime),
-): transaction is BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime {
+    transactionMessage: BaseTransactionMessage | (BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime),
+): transactionMessage is BaseTransactionMessage & TransactionMessageWithDurableNonceLifetime {
     return (
-        'lifetimeConstraint' in transaction &&
-        typeof transaction.lifetimeConstraint.nonce === 'string' &&
-        transaction.instructions[0] != null &&
-        isAdvanceNonceAccountInstruction(transaction.instructions[0])
+        'lifetimeConstraint' in transactionMessage &&
+        typeof transactionMessage.lifetimeConstraint.nonce === 'string' &&
+        transactionMessage.instructions[0] != null &&
+        isAdvanceNonceAccountInstruction(transactionMessage.instructions[0])
     );
 }
 
@@ -143,7 +143,7 @@ function isAdvanceNonceAccountInstructionForNonce<
 }
 
 export function setTransactionMessageLifetimeUsingDurableNonce<
-    TTransaction extends BaseTransactionMessage,
+    TTransactionMessage extends BaseTransactionMessage,
     TNonceAccountAddress extends string = string,
     TNonceAuthorityAddress extends string = string,
     TNonceValue extends string = string,
@@ -153,49 +153,52 @@ export function setTransactionMessageLifetimeUsingDurableNonce<
         nonceAccountAddress,
         nonceAuthorityAddress,
     }: DurableNonceConfig<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue>,
-    transaction: TTransaction | (TransactionMessageWithDurableNonceLifetime & TTransaction),
+    transactionMessage: TTransactionMessage | (TransactionMessageWithDurableNonceLifetime & TTransactionMessage),
 ): TransactionMessageWithDurableNonceLifetime<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue> &
-    TTransaction {
+    TTransactionMessage {
     let newInstructions: [
         AdvanceNonceAccountInstruction<TNonceAccountAddress, TNonceAuthorityAddress>,
         ...IInstruction[],
     ];
 
-    const firstInstruction = transaction.instructions[0];
+    const firstInstruction = transactionMessage.instructions[0];
     if (firstInstruction && isAdvanceNonceAccountInstruction(firstInstruction)) {
         if (isAdvanceNonceAccountInstructionForNonce(firstInstruction, nonceAccountAddress, nonceAuthorityAddress)) {
-            if (isDurableNonceTransaction(transaction) && transaction.lifetimeConstraint.nonce === nonce) {
-                return transaction as TransactionMessageWithDurableNonceLifetime<
+            if (
+                isDurableNonceTransaction(transactionMessage) &&
+                transactionMessage.lifetimeConstraint.nonce === nonce
+            ) {
+                return transactionMessage as TransactionMessageWithDurableNonceLifetime<
                     TNonceAccountAddress,
                     TNonceAuthorityAddress,
                     TNonceValue
                 > &
-                    TTransaction;
+                    TTransactionMessage;
             } else {
                 // we already have the right first instruction, leave it as-is
-                newInstructions = [firstInstruction, ...transaction.instructions.slice(1)];
+                newInstructions = [firstInstruction, ...transactionMessage.instructions.slice(1)];
             }
         } else {
             // we have a different advance nonce instruction as the first instruction, replace it
             newInstructions = [
                 Object.freeze(createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress)),
-                ...transaction.instructions.slice(1),
+                ...transactionMessage.instructions.slice(1),
             ];
         }
     } else {
         // we don't have an existing advance nonce instruction as the first instruction, prepend one
         newInstructions = [
             Object.freeze(createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress)),
-            ...transaction.instructions,
+            ...transactionMessage.instructions,
         ];
     }
 
     return Object.freeze({
-        ...transaction,
+        ...transactionMessage,
         instructions: Object.freeze(newInstructions),
         lifetimeConstraint: Object.freeze({
             nonce,
         }),
     }) as TransactionMessageWithDurableNonceLifetime<TNonceAccountAddress, TNonceAuthorityAddress, TNonceValue> &
-        TTransaction;
+        TTransactionMessage;
 }
diff --git a/packages/transaction-messages/src/instructions.ts b/packages/transaction-messages/src/instructions.ts
@@ -1,20 +1,20 @@
 import { TransactionMessageWithDurableNonceLifetime } from './durable-nonce';
 import { BaseTransactionMessage } from './transaction-message';
 
-export function appendTransactionMessageInstruction<TTransaction extends BaseTransactionMessage>(
-    instruction: TTransaction['instructions'][number],
-    transaction: TTransaction,
-): TTransaction {
-    return appendTransactionMessageInstructions([instruction], transaction);
+export function appendTransactionMessageInstruction<TTransactionMessage extends BaseTransactionMessage>(
+    instruction: TTransactionMessage['instructions'][number],
+    transactionMessage: TTransactionMessage,
+): TTransactionMessage {
+    return appendTransactionMessageInstructions([instruction], transactionMessage);
 }
 
-export function appendTransactionMessageInstructions<TTransaction extends BaseTransactionMessage>(
-    instructions: ReadonlyArray<TTransaction['instructions'][number]>,
-    transaction: TTransaction,
-): TTransaction {
+export function appendTransactionMessageInstructions<TTransactionMessage extends BaseTransactionMessage>(
+    instructions: ReadonlyArray<TTransactionMessage['instructions'][number]>,
+    transactionMessage: TTransactionMessage,
+): TTransactionMessage {
     return Object.freeze({
-        ...transaction,
-        instructions: Object.freeze([...transaction.instructions, ...instructions]),
+        ...transactionMessage,
+        instructions: Object.freeze([...transactionMessage.instructions, ...instructions]),
     });
 }
 
@@ -24,19 +24,19 @@ type ExcludeDurableNonce<T> = T extends TransactionMessageWithDurableNonceLifeti
     ? BaseTransactionMessage & Omit<T, keyof TransactionMessageWithDurableNonceLifetime>
     : T;
 
-export function prependTransactionMessageInstruction<TTransaction extends BaseTransactionMessage>(
-    instruction: TTransaction['instructions'][number],
-    transaction: TTransaction,
-): ExcludeDurableNonce<TTransaction> {
-    return prependTransactionMessageInstructions([instruction], transaction);
+export function prependTransactionMessageInstruction<TTransactionMessage extends BaseTransactionMessage>(
+    instruction: TTransactionMessage['instructions'][number],
+    transactionMessage: TTransactionMessage,
+): ExcludeDurableNonce<TTransactionMessage> {
+    return prependTransactionMessageInstructions([instruction], transactionMessage);
 }
 
-export function prependTransactionMessageInstructions<TTransaction extends BaseTransactionMessage>(
-    instructions: ReadonlyArray<TTransaction['instructions'][number]>,
-    transaction: TTransaction,
-): ExcludeDurableNonce<TTransaction> {
+export function prependTransactionMessageInstructions<TTransactionMessage extends BaseTransactionMessage>(
+    instructions: ReadonlyArray<TTransactionMessage['instructions'][number]>,
+    transactionMessage: TTransactionMessage,
+): ExcludeDurableNonce<TTransactionMessage> {
     return Object.freeze({
-        ...transaction,
-        instructions: Object.freeze([...instructions, ...transaction.instructions]),
-    }) as ExcludeDurableNonce<TTransaction>;
+        ...transactionMessage,
+        instructions: Object.freeze([...instructions, ...transactionMessage.instructions]),
+    }) as ExcludeDurableNonce<TTransactionMessage>;
 }
