@solana/transactions 2.0.0-experimental.b419cd0 → 2.0.0-experimental.b5bbd3a

package/dist/index.browser.cjs

@@ -1,15 +1,14 @@
 'use strict';
 
 var codecsStrings = require('@solana/codecs-strings');
+var addresses = require('@solana/addresses');
 var codecsCore = require('@solana/codecs-core');
 var codecsDataStructures = require('@solana/codecs-data-structures');
 var codecsNumbers = require('@solana/codecs-numbers');
-var addresses = require('@solana/addresses');
 var functional = require('@solana/functional');
 var keys = require('@solana/keys');
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+// src/blockhash.ts
 
 // src/unsigned-transaction.ts
 function getUnsignedTransaction(transaction) {
@@ -49,6 +48,22 @@ function assertIsBlockhash(putativeBlockhash) {
     });
   }
 }
+function isTransactionWithBlockhashLifetime(transaction) {
+  const lifetimeConstraintShapeMatches = "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.blockhash === "string" && typeof transaction.lifetimeConstraint.lastValidBlockHeight === "bigint";
+  if (!lifetimeConstraintShapeMatches)
+    return false;
+  try {
+    assertIsBlockhash(transaction.lifetimeConstraint.blockhash);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertIsTransactionWithBlockhashLifetime(transaction) {
+  if (!isTransactionWithBlockhashLifetime(transaction)) {
+    throw new Error("Transaction does not have a blockhash lifetime");
+  }
+}
 function setTransactionLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
   if ("lifetimeConstraint" in transaction && transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) {
     return transaction;
@@ -254,7 +269,7 @@ function getAddressMapFromInstructions(feePayer, instructions) {
                 const shouldReplaceEntry = (
                   // Consider using the new LOOKUP_TABLE if its address is different...
                   entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
-                  (addressComparator || (addressComparator = addresses.getAddressComparator()))(
+                  (addressComparator ||= addresses.getAddressComparator())(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -360,7 +375,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = addresses.getAddressComparator());
+    addressComparator ||= addresses.getAddressComparator();
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -373,16 +388,15 @@ function getOrderedAccountsFromAddressMap(addressMap) {
   return orderedAccounts;
 }
 function getCompiledAddressTableLookups(orderedAccounts) {
-  var _a;
   const index = {};
   for (const account of orderedAccounts) {
     if (!("lookupTableAddress" in account)) {
       continue;
     }
-    const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
+    const entry = index[account.lookupTableAddress] ||= {
       readableIndices: [],
       writableIndices: []
-    });
+    };
     if (account.role === AccountRole.WRITABLE) {
       entry.writableIndices.push(account.addressIndex);
     } else {
@@ -468,6 +482,216 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
+var memoizedAddressTableLookupEncoder;
+function getAddressTableLookupEncoder() {
+  if (!memoizedAddressTableLookupEncoder) {
+    memoizedAddressTableLookupEncoder = codecsDataStructures.getStructEncoder([
+      ["lookupTableAddress", addresses.getAddressEncoder()],
+      [
+        "writableIndices",
+        codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), { size: codecsNumbers.getShortU16Encoder() })
+      ],
+      [
+        "readableIndices",
+        codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), { size: codecsNumbers.getShortU16Encoder() })
+      ]
+    ]);
+  }
+  return memoizedAddressTableLookupEncoder;
+}
+var memoizedAddressTableLookupDecoder;
+function getAddressTableLookupDecoder() {
+  if (!memoizedAddressTableLookupDecoder) {
+    memoizedAddressTableLookupDecoder = codecsDataStructures.getStructDecoder([
+      ["lookupTableAddress", addresses.getAddressDecoder()],
+      ["writableIndices", codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), { size: codecsNumbers.getShortU16Decoder() })],
+      ["readableIndices", codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), { size: codecsNumbers.getShortU16Decoder() })]
+    ]);
+  }
+  return memoizedAddressTableLookupDecoder;
+}
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+  if (!memoizedU8Encoder)
+    memoizedU8Encoder = codecsNumbers.getU8Encoder();
+  return memoizedU8Encoder;
+}
+var memoizedU8Decoder;
+function getMemoizedU8Decoder() {
+  if (!memoizedU8Decoder)
+    memoizedU8Decoder = codecsNumbers.getU8Decoder();
+  return memoizedU8Decoder;
+}
+function getMessageHeaderEncoder() {
+  return codecsDataStructures.getStructEncoder([
+    ["numSignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
+  ]);
+}
+function getMessageHeaderDecoder() {
+  return codecsDataStructures.getStructDecoder([
+    ["numSignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Decoder()]
+  ]);
+}
+var memoizedGetInstructionEncoder;
+function getInstructionEncoder() {
+  if (!memoizedGetInstructionEncoder) {
+    memoizedGetInstructionEncoder = codecsCore.mapEncoder(
+      codecsDataStructures.getStructEncoder([
+        ["programAddressIndex", codecsNumbers.getU8Encoder()],
+        ["accountIndices", codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), { size: codecsNumbers.getShortU16Encoder() })],
+        ["data", codecsDataStructures.getBytesEncoder({ size: codecsNumbers.getShortU16Encoder() })]
+      ]),
+      // Convert an instruction to have all fields defined
+      (instruction) => {
+        if (instruction.accountIndices !== void 0 && instruction.data !== void 0) {
+          return instruction;
+        }
+        return {
+          ...instruction,
+          accountIndices: instruction.accountIndices ?? [],
+          data: instruction.data ?? new Uint8Array(0)
+        };
+      }
+    );
+  }
+  return memoizedGetInstructionEncoder;
+}
+var memoizedGetInstructionDecoder;
+function getInstructionDecoder() {
+  if (!memoizedGetInstructionDecoder) {
+    memoizedGetInstructionDecoder = codecsCore.mapDecoder(
+      codecsDataStructures.getStructDecoder([
+        ["programAddressIndex", codecsNumbers.getU8Decoder()],
+        ["accountIndices", codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), { size: codecsNumbers.getShortU16Decoder() })],
+        ["data", codecsDataStructures.getBytesDecoder({ size: codecsNumbers.getShortU16Decoder() })]
+      ]),
+      // Convert an instruction to exclude optional fields if they are empty
+      (instruction) => {
+        if (instruction.accountIndices.length && instruction.data.byteLength) {
+          return instruction;
+        }
+        const { accountIndices, data, ...rest } = instruction;
+        return {
+          ...rest,
+          ...accountIndices.length ? { accountIndices } : null,
+          ...data.byteLength ? { data } : null
+        };
+      }
+    );
+  }
+  return memoizedGetInstructionDecoder;
+}
+var VERSION_FLAG_MASK = 128;
+function getTransactionVersionEncoder() {
+  return codecsCore.createEncoder({
+    getSizeFromValue: (value) => value === "legacy" ? 0 : 1,
+    maxSize: 1,
+    write: (value, bytes, offset) => {
+      if (value === "legacy") {
+        return offset;
+      }
+      if (value < 0 || value > 127) {
+        throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
+      }
+      bytes.set([value | VERSION_FLAG_MASK], offset);
+      return offset + 1;
+    }
+  });
+}
+function getTransactionVersionDecoder() {
+  return codecsCore.createDecoder({
+    maxSize: 1,
+    read: (bytes, offset) => {
+      const firstByte = bytes[offset];
+      if ((firstByte & VERSION_FLAG_MASK) === 0) {
+        return ["legacy", offset];
+      } else {
+        const version = firstByte ^ VERSION_FLAG_MASK;
+        return [version, offset + 1];
+      }
+    }
+  });
+}
+
+// src/serializers/message.ts
+function getCompiledMessageLegacyEncoder() {
+  return codecsDataStructures.getStructEncoder(getPreludeStructEncoderTuple());
+}
+function getCompiledMessageVersionedEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ...getPreludeStructEncoderTuple(),
+      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
+    ]),
+    (value) => {
+      if (value.version === "legacy") {
+        return value;
+      }
+      return {
+        ...value,
+        addressTableLookups: value.addressTableLookups ?? []
+      };
+    }
+  );
+}
+function getPreludeStructEncoderTuple() {
+  return [
+    ["version", getTransactionVersionEncoder()],
+    ["header", getMessageHeaderEncoder()],
+    ["staticAccounts", codecsDataStructures.getArrayEncoder(addresses.getAddressEncoder(), { size: codecsNumbers.getShortU16Encoder() })],
+    ["lifetimeToken", codecsStrings.getStringEncoder({ encoding: codecsStrings.getBase58Encoder(), size: 32 })],
+    ["instructions", codecsDataStructures.getArrayEncoder(getInstructionEncoder(), { size: codecsNumbers.getShortU16Encoder() })]
+  ];
+}
+function getPreludeStructDecoderTuple() {
+  return [
+    ["version", getTransactionVersionDecoder()],
+    ["header", getMessageHeaderDecoder()],
+    ["staticAccounts", codecsDataStructures.getArrayDecoder(addresses.getAddressDecoder(), { size: codecsNumbers.getShortU16Decoder() })],
+    ["lifetimeToken", codecsStrings.getStringDecoder({ encoding: codecsStrings.getBase58Decoder(), size: 32 })],
+    ["instructions", codecsDataStructures.getArrayDecoder(getInstructionDecoder(), { size: codecsNumbers.getShortU16Decoder() })],
+    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
+  ];
+}
+function getAddressTableLookupArrayEncoder() {
+  return codecsDataStructures.getArrayEncoder(getAddressTableLookupEncoder(), { size: codecsNumbers.getShortU16Encoder() });
+}
+function getAddressTableLookupArrayDecoder() {
+  return codecsDataStructures.getArrayDecoder(getAddressTableLookupDecoder(), { size: codecsNumbers.getShortU16Decoder() });
+}
+function getCompiledMessageEncoder() {
+  return codecsCore.createEncoder({
+    getSizeFromValue: (compiledMessage) => {
+      if (compiledMessage.version === "legacy") {
+        return getCompiledMessageLegacyEncoder().getSizeFromValue(compiledMessage);
+      } else {
+        return getCompiledMessageVersionedEncoder().getSizeFromValue(compiledMessage);
+      }
+    },
+    write: (compiledMessage, bytes, offset) => {
+      if (compiledMessage.version === "legacy") {
+        return getCompiledMessageLegacyEncoder().write(compiledMessage, bytes, offset);
+      } else {
+        return getCompiledMessageVersionedEncoder().write(compiledMessage, bytes, offset);
+      }
+    }
+  });
+}
+function getCompiledMessageDecoder() {
+  return codecsCore.mapDecoder(codecsDataStructures.getStructDecoder(getPreludeStructDecoderTuple()), ({ addressTableLookups, ...restOfMessage }) => {
+    if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+      return restOfMessage;
+    }
+    return { ...restOfMessage, addressTableLookups };
+  });
+}
+function getCompiledMessageCodec() {
+  return codecsCore.combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
+}
 
 // src/compile-transaction.ts
 function getCompiledTransaction(transaction) {
@@ -596,380 +820,24 @@ function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
     (tx) => compiledTransaction.signatures.length ? { ...tx, signatures } : tx
   );
 }
-var lookupTableAddressDescription = __DEV__ ? "The address of the address lookup table account from which instruction addresses should be looked up" : "lookupTableAddress";
-var writableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as writeable" : "writableIndices";
-var readableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as read-only" : "readableIndices";
-var addressTableLookupDescription = __DEV__ ? "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it" : "addressTableLookup";
-var memoizedAddressTableLookupEncoder;
-function getAddressTableLookupEncoder() {
-  if (!memoizedAddressTableLookupEncoder) {
-    memoizedAddressTableLookupEncoder = codecsDataStructures.getStructEncoder(
-      [
-        ["lookupTableAddress", addresses.getAddressEncoder({ description: lookupTableAddressDescription })],
-        [
-          "writableIndices",
-          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
-            description: writableIndicesDescription,
-            size: codecsNumbers.getShortU16Encoder()
-          })
-        ],
-        [
-          "readableIndices",
-          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
-            description: readableIndicesDescription,
-            size: codecsNumbers.getShortU16Encoder()
-          })
-        ]
-      ],
-      { description: addressTableLookupDescription }
-    );
-  }
-  return memoizedAddressTableLookupEncoder;
-}
-var memoizedAddressTableLookupDecoder;
-function getAddressTableLookupDecoder() {
-  if (!memoizedAddressTableLookupDecoder) {
-    memoizedAddressTableLookupDecoder = codecsDataStructures.getStructDecoder(
-      [
-        ["lookupTableAddress", addresses.getAddressDecoder({ description: lookupTableAddressDescription })],
-        [
-          "writableIndices",
-          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
-            description: writableIndicesDescription,
-            size: codecsNumbers.getShortU16Decoder()
-          })
-        ],
-        [
-          "readableIndices",
-          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
-            description: readableIndicesDescription,
-            size: codecsNumbers.getShortU16Decoder()
-          })
-        ]
-      ],
-      { description: addressTableLookupDescription }
-    );
-  }
-  return memoizedAddressTableLookupDecoder;
-}
-var memoizedU8Encoder;
-function getMemoizedU8Encoder() {
-  if (!memoizedU8Encoder)
-    memoizedU8Encoder = codecsNumbers.getU8Encoder();
-  return memoizedU8Encoder;
-}
-function getMemoizedU8EncoderDescription(description) {
-  const encoder = getMemoizedU8Encoder();
-  return {
-    ...encoder,
-    description: description ?? encoder.description
-  };
-}
-var memoizedU8Decoder;
-function getMemoizedU8Decoder() {
-  if (!memoizedU8Decoder)
-    memoizedU8Decoder = codecsNumbers.getU8Decoder();
-  return memoizedU8Decoder;
-}
-function getMemoizedU8DecoderDescription(description) {
-  const decoder = getMemoizedU8Decoder();
-  return {
-    ...decoder,
-    description: description ?? decoder.description
-  };
-}
-var numSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" : void 0;
-var numReadonlySignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable" : void 0;
-var numReadonlyNonSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable" : void 0;
-var messageHeaderDescription = __DEV__ ? "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses" : void 0;
-function getMessageHeaderEncoder() {
-  return codecsDataStructures.getStructEncoder(
-    [
-      ["numSignerAccounts", getMemoizedU8EncoderDescription(numSignerAccountsDescription)],
-      ["numReadonlySignerAccounts", getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)]
-    ],
-    {
-      description: messageHeaderDescription
-    }
-  );
-}
-function getMessageHeaderDecoder() {
-  return codecsDataStructures.getStructDecoder(
-    [
-      ["numSignerAccounts", getMemoizedU8DecoderDescription(numSignerAccountsDescription)],
-      ["numReadonlySignerAccounts", getMemoizedU8DecoderDescription(numReadonlySignerAccountsDescription)],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8DecoderDescription(numReadonlyNonSignerAccountsDescription)]
-    ],
-    {
-      description: messageHeaderDescription
-    }
-  );
-}
-var programAddressIndexDescription = __DEV__ ? "The index of the program being called, according to the well-ordered accounts list for this transaction" : "programAddressIndex";
-var accountIndexDescription = __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : void 0;
-var accountIndicesDescription = __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "accountIndices";
-var dataDescription = __DEV__ ? "An optional buffer of data passed to the instruction" : "data";
-var memoizedGetInstructionEncoder;
-function getInstructionEncoder() {
-  if (!memoizedGetInstructionEncoder) {
-    memoizedGetInstructionEncoder = codecsCore.mapEncoder(
-      codecsDataStructures.getStructEncoder([
-        ["programAddressIndex", codecsNumbers.getU8Encoder({ description: programAddressIndexDescription })],
-        [
-          "accountIndices",
-          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder({ description: accountIndexDescription }), {
-            description: accountIndicesDescription,
-            size: codecsNumbers.getShortU16Encoder()
-          })
-        ],
-        ["data", codecsDataStructures.getBytesEncoder({ description: dataDescription, size: codecsNumbers.getShortU16Encoder() })]
-      ]),
-      // Convert an instruction to have all fields defined
-      (instruction) => {
-        if (instruction.accountIndices !== void 0 && instruction.data !== void 0) {
-          return instruction;
-        }
-        return {
-          ...instruction,
-          accountIndices: instruction.accountIndices ?? [],
-          data: instruction.data ?? new Uint8Array(0)
-        };
-      }
-    );
-  }
-  return memoizedGetInstructionEncoder;
-}
-var memoizedGetInstructionDecoder;
-function getInstructionDecoder() {
-  if (!memoizedGetInstructionDecoder) {
-    memoizedGetInstructionDecoder = codecsCore.mapDecoder(
-      codecsDataStructures.getStructDecoder([
-        ["programAddressIndex", codecsNumbers.getU8Decoder({ description: programAddressIndexDescription })],
-        [
-          "accountIndices",
-          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder({ description: accountIndexDescription }), {
-            description: accountIndicesDescription,
-            size: codecsNumbers.getShortU16Decoder()
-          })
-        ],
-        ["data", codecsDataStructures.getBytesDecoder({ description: dataDescription, size: codecsNumbers.getShortU16Decoder() })]
-      ]),
-      // Convert an instruction to exclude optional fields if they are empty
-      (instruction) => {
-        if (instruction.accountIndices.length && instruction.data.byteLength) {
-          return instruction;
-        }
-        const { accountIndices, data, ...rest } = instruction;
-        return {
-          ...rest,
-          ...accountIndices.length ? { accountIndices } : null,
-          ...data.byteLength ? { data } : null
-        };
-      }
-    );
-  }
-  return memoizedGetInstructionDecoder;
-}
-var VERSION_FLAG_MASK = 128;
-var BASE_CONFIG = {
-  description: __DEV__ ? "A single byte that encodes the version of the transaction" : "",
-  fixedSize: null,
-  maxSize: 1
-};
-function decode(bytes, offset = 0) {
-  const firstByte = bytes[offset];
-  if ((firstByte & VERSION_FLAG_MASK) === 0) {
-    return ["legacy", offset];
-  } else {
-    const version = firstByte ^ VERSION_FLAG_MASK;
-    return [version, offset + 1];
-  }
-}
-function encode(value) {
-  if (value === "legacy") {
-    return new Uint8Array();
-  }
-  if (value < 0 || value > 127) {
-    throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
-  }
-  return new Uint8Array([value | VERSION_FLAG_MASK]);
-}
-function getTransactionVersionDecoder() {
-  return {
-    ...BASE_CONFIG,
-    decode
-  };
-}
-function getTransactionVersionEncoder() {
-  return {
-    ...BASE_CONFIG,
-    encode
-  };
-}
-
-// src/serializers/message.ts
-var staticAccountsDescription = __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "staticAccounts";
-var lifetimeTokenDescription = __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "lifetimeToken";
-var instructionsDescription = __DEV__ ? "A compact-array of instructions belonging to this transaction" : "instructions";
-var addressTableLookupsDescription = __DEV__ ? "A compact array of address table lookups belonging to this transaction" : "addressTableLookups";
-function getCompiledMessageLegacyEncoder() {
-  return codecsDataStructures.getStructEncoder(getPreludeStructEncoderTuple());
-}
-function getCompiledMessageVersionedEncoder() {
-  return codecsCore.mapEncoder(
-    codecsDataStructures.getStructEncoder([
-      ...getPreludeStructEncoderTuple(),
-      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
-    ]),
-    (value) => {
-      if (value.version === "legacy") {
-        return value;
-      }
-      return {
-        ...value,
-        addressTableLookups: value.addressTableLookups ?? []
-      };
-    }
-  );
-}
-function getPreludeStructEncoderTuple() {
-  return [
-    ["version", getTransactionVersionEncoder()],
-    ["header", getMessageHeaderEncoder()],
-    [
-      "staticAccounts",
-      codecsDataStructures.getArrayEncoder(addresses.getAddressEncoder(), {
-        description: staticAccountsDescription,
-        size: codecsNumbers.getShortU16Encoder()
-      })
-    ],
-    [
-      "lifetimeToken",
-      codecsStrings.getStringEncoder({
-        description: lifetimeTokenDescription,
-        encoding: codecsStrings.getBase58Encoder(),
-        size: 32
-      })
-    ],
-    [
-      "instructions",
-      codecsDataStructures.getArrayEncoder(getInstructionEncoder(), {
-        description: instructionsDescription,
-        size: codecsNumbers.getShortU16Encoder()
-      })
-    ]
-  ];
-}
-function getPreludeStructDecoderTuple() {
-  return [
-    ["version", getTransactionVersionDecoder()],
-    ["header", getMessageHeaderDecoder()],
-    [
-      "staticAccounts",
-      codecsDataStructures.getArrayDecoder(addresses.getAddressDecoder(), {
-        description: staticAccountsDescription,
-        size: codecsNumbers.getShortU16Decoder()
-      })
-    ],
-    [
-      "lifetimeToken",
-      codecsStrings.getStringDecoder({
-        description: lifetimeTokenDescription,
-        encoding: codecsStrings.getBase58Decoder(),
-        size: 32
-      })
-    ],
-    [
-      "instructions",
-      codecsDataStructures.getArrayDecoder(getInstructionDecoder(), {
-        description: instructionsDescription,
-        size: codecsNumbers.getShortU16Decoder()
-      })
-    ],
-    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
-  ];
-}
-function getAddressTableLookupArrayEncoder() {
-  return codecsDataStructures.getArrayEncoder(getAddressTableLookupEncoder(), {
-    description: addressTableLookupsDescription,
-    size: codecsNumbers.getShortU16Encoder()
-  });
-}
-function getAddressTableLookupArrayDecoder() {
-  return codecsDataStructures.getArrayDecoder(getAddressTableLookupDecoder(), {
-    description: addressTableLookupsDescription,
-    size: codecsNumbers.getShortU16Decoder()
-  });
-}
-var messageDescription = __DEV__ ? "The wire format of a Solana transaction message" : "message";
-function getCompiledMessageEncoder() {
-  return {
-    description: messageDescription,
-    encode: (compiledMessage) => {
-      if (compiledMessage.version === "legacy") {
-        return getCompiledMessageLegacyEncoder().encode(compiledMessage);
-      } else {
-        return getCompiledMessageVersionedEncoder().encode(compiledMessage);
-      }
-    },
-    fixedSize: null,
-    maxSize: null
-  };
-}
-function getCompiledMessageDecoder() {
-  return codecsCore.mapDecoder(
-    codecsDataStructures.getStructDecoder(getPreludeStructDecoderTuple(), {
-      description: messageDescription
-    }),
-    ({ addressTableLookups, ...restOfMessage }) => {
-      if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
-        return restOfMessage;
-      }
-      return { ...restOfMessage, addressTableLookups };
-    }
-  );
-}
 
 // src/serializers/transaction.ts
-var signaturesDescription = __DEV__ ? "A compact array of 64-byte, base-64 encoded Ed25519 signatures" : "signatures";
-var transactionDescription = __DEV__ ? "The wire format of a Solana transaction" : "transaction";
 function getCompiledTransactionEncoder() {
-  return codecsDataStructures.getStructEncoder(
-    [
-      [
-        "signatures",
-        codecsDataStructures.getArrayEncoder(codecsDataStructures.getBytesEncoder({ size: 64 }), {
-          description: signaturesDescription,
-          size: codecsNumbers.getShortU16Encoder()
-        })
-      ],
-      ["compiledMessage", getCompiledMessageEncoder()]
-    ],
-    {
-      description: transactionDescription
-    }
-  );
-}
-function getSignatureDecoder() {
-  return codecsCore.mapDecoder(codecsDataStructures.getBytesDecoder({ size: 64 }), (bytes) => bytes);
+  return codecsDataStructures.getStructEncoder([
+    ["signatures", codecsDataStructures.getArrayEncoder(codecsDataStructures.getBytesEncoder({ size: 64 }), { size: codecsNumbers.getShortU16Encoder() })],
+    ["compiledMessage", getCompiledMessageEncoder()]
+  ]);
 }
 function getCompiledTransactionDecoder() {
-  return codecsDataStructures.getStructDecoder(
+  return codecsDataStructures.getStructDecoder([
     [
-      [
-        "signatures",
-        codecsDataStructures.getArrayDecoder(getSignatureDecoder(), {
-          description: signaturesDescription,
-          size: codecsNumbers.getShortU16Decoder()
-        })
-      ],
-      ["compiledMessage", getCompiledMessageDecoder()]
+      "signatures",
+      codecsDataStructures.getArrayDecoder(codecsDataStructures.getBytesDecoder({ size: 64 }), {
+        size: codecsNumbers.getShortU16Decoder()
+      })
     ],
-    {
-      description: transactionDescription
-    }
-  );
+    ["compiledMessage", getCompiledMessageDecoder()]
+  ]);
 }
 function getTransactionEncoder() {
   return codecsCore.mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
@@ -993,7 +861,7 @@ function getSignatureFromTransaction(transaction) {
       "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
     );
   }
-  const transactionSignature = base58Decoder.decode(signatureBytes)[0];
+  const transactionSignature = base58Decoder.decode(signatureBytes);
   return transactionSignature;
 }
 async function partiallySignTransaction(keyPairs, transaction) {
@@ -1030,21 +898,22 @@ function assertTransactionIsFullySigned(transaction) {
     }
   });
 }
-
-// src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
   const wireTransactionBytes = getTransactionEncoder().encode(transaction);
-  {
-    return btoa(String.fromCharCode(...wireTransactionBytes));
-  }
+  return codecsStrings.getBase64Decoder().decode(wireTransactionBytes);
 }
 
 exports.appendTransactionInstruction = appendTransactionInstruction;
 exports.assertIsBlockhash = assertIsBlockhash;
 exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
+exports.assertIsTransactionWithBlockhashLifetime = assertIsTransactionWithBlockhashLifetime;
 exports.assertTransactionIsFullySigned = assertTransactionIsFullySigned;
+exports.compileMessage = compileMessage;
 exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
+exports.getCompiledMessageCodec = getCompiledMessageCodec;
+exports.getCompiledMessageDecoder = getCompiledMessageDecoder;
+exports.getCompiledMessageEncoder = getCompiledMessageEncoder;
 exports.getSignatureFromTransaction = getSignatureFromTransaction;
 exports.getTransactionCodec = getTransactionCodec;
 exports.getTransactionDecoder = getTransactionDecoder;