@solana/transaction-messages 2.1.1-canary-20250425205850 → 2.1.1-canary-20250425210025

package/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
     }

package/dist/index.browser.cjs

@@ -10,27 +10,27 @@ var instructions = require('@solana/instructions');
 var functional = require('@solana/functional');
 
 // src/blockhash.ts
-function isTransactionMessageWithBlockhashLifetime(transaction) {
-  const lifetimeConstraintShapeMatches = "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.blockhash === "string" && typeof transaction.lifetimeConstraint.lastValidBlockHeight === "bigint";
+function isTransactionMessageWithBlockhashLifetime(transactionMessage) {
+  const lifetimeConstraintShapeMatches = "lifetimeConstraint" in transactionMessage && typeof transactionMessage.lifetimeConstraint.blockhash === "string" && typeof transactionMessage.lifetimeConstraint.lastValidBlockHeight === "bigint";
   if (!lifetimeConstraintShapeMatches) return false;
   try {
-    rpcTypes.assertIsBlockhash(transaction.lifetimeConstraint.blockhash);
+    rpcTypes.assertIsBlockhash(transactionMessage.lifetimeConstraint.blockhash);
     return true;
   } catch {
     return false;
   }
 }
-function assertIsTransactionMessageWithBlockhashLifetime(transaction) {
-  if (!isTransactionMessageWithBlockhashLifetime(transaction)) {
+function assertIsTransactionMessageWithBlockhashLifetime(transactionMessage) {
+  if (!isTransactionMessageWithBlockhashLifetime(transactionMessage)) {
     throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME);
   }
 }
-function setTransactionMessageLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
-  if ("lifetimeConstraint" in transaction && transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) {
-    return transaction;
+function setTransactionMessageLifetimeUsingBlockhash(blockhashLifetimeConstraint, transactionMessage) {
+  if ("lifetimeConstraint" in transactionMessage && transactionMessage.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transactionMessage.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) {
+    return transactionMessage;
   }
   const out = {
-    ...transaction,
+    ...transactionMessage,
     lifetimeConstraint: Object.freeze(blockhashLifetimeConstraint)
   };
   Object.freeze(out);
@@ -586,16 +586,19 @@ function getCompiledStaticAccounts(orderedAccounts) {
 }
 
 // src/compile/message.ts
-function compileTransactionMessage(transaction) {
-  const addressMap = getAddressMapFromInstructions(transaction.feePayer.address, transaction.instructions);
+function compileTransactionMessage(transactionMessage) {
+  const addressMap = getAddressMapFromInstructions(
+    transactionMessage.feePayer.address,
+    transactionMessage.instructions
+  );
   const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
   return {
-    ...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
+    ...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
   };
 }
 function findAddressInLookupTables(address, role, addressesByLookupTableAddress) {
@@ -657,8 +660,8 @@ function createTransactionMessage({
 }
 var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
 var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-function assertIsDurableNonceTransactionMessage(transaction) {
-  if (!isDurableNonceTransaction(transaction)) {
+function assertIsDurableNonceTransactionMessage(transactionMessage) {
+  if (!isDurableNonceTransaction(transactionMessage)) {
     throw new errors.SolanaError(errors.SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME);
   }
 }
@@ -687,8 +690,8 @@ function isAdvanceNonceAccountInstruction(instruction) {
 function isAdvanceNonceAccountInstructionData(data) {
   return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
 }
-function isDurableNonceTransaction(transaction) {
-  return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
+function isDurableNonceTransaction(transactionMessage) {
+  return "lifetimeConstraint" in transactionMessage && typeof transactionMessage.lifetimeConstraint.nonce === "string" && transactionMessage.instructions[0] != null && isAdvanceNonceAccountInstruction(transactionMessage.instructions[0]);
 }
 function isAdvanceNonceAccountInstructionForNonce(instruction, nonceAccountAddress, nonceAuthorityAddress) {
   return instruction.accounts[0].address === nonceAccountAddress && instruction.accounts[2].address === nonceAuthorityAddress;
@@ -697,30 +700,30 @@ function setTransactionMessageLifetimeUsingDurableNonce({
   nonce,
   nonceAccountAddress,
   nonceAuthorityAddress
-}, transaction) {
+}, transactionMessage) {
   let newInstructions;
-  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;
+      if (isDurableNonceTransaction(transactionMessage) && transactionMessage.lifetimeConstraint.nonce === nonce) {
+        return transactionMessage;
       } else {
-        newInstructions = [firstInstruction, ...transaction.instructions.slice(1)];
+        newInstructions = [firstInstruction, ...transactionMessage.instructions.slice(1)];
       }
     } else {
       newInstructions = [
         Object.freeze(createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress)),
-        ...transaction.instructions.slice(1)
+        ...transactionMessage.instructions.slice(1)
       ];
     }
   } else {
     newInstructions = [
       Object.freeze(createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress)),
-      ...transaction.instructions
+      ...transactionMessage.instructions
     ];
   }
   return Object.freeze({
-    ...transaction,
+    ...transactionMessage,
     instructions: Object.freeze(newInstructions),
     lifetimeConstraint: Object.freeze({
       nonce
@@ -745,22 +748,22 @@ function isAddressOnlyFeePayer(feePayer) {
 }
 
 // src/instructions.ts
-function appendTransactionMessageInstruction(instruction, transaction) {
-  return appendTransactionMessageInstructions([instruction], transaction);
+function appendTransactionMessageInstruction(instruction, transactionMessage) {
+  return appendTransactionMessageInstructions([instruction], transactionMessage);
 }
-function appendTransactionMessageInstructions(instructions, transaction) {
+function appendTransactionMessageInstructions(instructions, transactionMessage) {
   return Object.freeze({
-    ...transaction,
-    instructions: Object.freeze([...transaction.instructions, ...instructions])
+    ...transactionMessage,
+    instructions: Object.freeze([...transactionMessage.instructions, ...instructions])
   });
 }
-function prependTransactionMessageInstruction(instruction, transaction) {
-  return prependTransactionMessageInstructions([instruction], transaction);
+function prependTransactionMessageInstruction(instruction, transactionMessage) {
+  return prependTransactionMessageInstructions([instruction], transactionMessage);
 }
-function prependTransactionMessageInstructions(instructions, transaction) {
+function prependTransactionMessageInstructions(instructions, transactionMessage) {
   return Object.freeze({
-    ...transaction,
-    instructions: Object.freeze([...instructions, ...transaction.instructions])
+    ...transactionMessage,
+    instructions: Object.freeze([...instructions, ...transactionMessage.instructions])
   });
 }
 
@@ -897,11 +900,11 @@ function decompileTransactionMessage(compiledTransactionMessage, config) {
   );
   return functional.pipe(
     createTransactionMessage({ version: compiledTransactionMessage.version }),
-    (tx) => setTransactionMessageFeePayer(feePayer, tx),
-    (tx) => instructions.reduce((acc, instruction) => {
+    (m) => setTransactionMessageFeePayer(feePayer, m),
+    (m) => instructions.reduce((acc, instruction) => {
       return appendTransactionMessageInstruction(instruction, acc);
-    }, tx),
-    (tx) => "blockhash" in lifetimeConstraint ? setTransactionMessageLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionMessageLifetimeUsingDurableNonce(lifetimeConstraint, tx)
+    }, m),
+    (m) => "blockhash" in lifetimeConstraint ? setTransactionMessageLifetimeUsingBlockhash(lifetimeConstraint, m) : setTransactionMessageLifetimeUsingDurableNonce(lifetimeConstraint, m)
   );
 }