@solana/transactions 2.0.0-experimental.762ff13 → 2.0.0-experimental.76cf6b4

package/dist/index.browser.js

@@ -1,13 +1,12 @@
-import { getBase58Encoder, getBase58Decoder, getStringEncoder, getStringDecoder } from '@solana/codecs-strings';
-import { mapEncoder, mapDecoder, combineCodec } from '@solana/codecs-core';
-import { getStructEncoder, getArrayEncoder, getBytesEncoder, getStructDecoder, getArrayDecoder, getBytesDecoder } from '@solana/codecs-data-structures';
+import { getBase58Encoder, getBase58Decoder, getBase64Decoder, getStringEncoder, getStringDecoder } from '@solana/codecs-strings';
+import { getAddressFromPublicKey, getAddressComparator, getAddressEncoder, getAddressDecoder, assertIsAddress } from '@solana/addresses';
+import { createEncoder, mapDecoder, combineCodec, mapEncoder, createDecoder } from '@solana/codecs-core';
+import { getStructDecoder, getStructEncoder, getArrayEncoder, getArrayDecoder, getBytesEncoder, getBytesDecoder } from '@solana/codecs-data-structures';
 import { getShortU16Encoder, getShortU16Decoder, getU8Encoder, getU8Decoder } from '@solana/codecs-numbers';
-import { getAddressFromPublicKey, getAddressComparator, assertIsAddress, getAddressEncoder, getAddressDecoder } from '@solana/addresses';
 import { pipe } from '@solana/functional';
 import { signBytes } from '@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) {
@@ -47,6 +46,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;
@@ -252,7 +267,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 = getAddressComparator()))(
+                  (addressComparator ||= getAddressComparator())(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -358,7 +373,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = getAddressComparator());
+    addressComparator ||= getAddressComparator();
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -371,16 +386,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 {
@@ -466,6 +480,216 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
+var memoizedAddressTableLookupEncoder;
+function getAddressTableLookupEncoder() {
+  if (!memoizedAddressTableLookupEncoder) {
+    memoizedAddressTableLookupEncoder = getStructEncoder([
+      ["lookupTableAddress", getAddressEncoder()],
+      [
+        "writableIndices",
+        getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
+      ],
+      [
+        "readableIndices",
+        getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
+      ]
+    ]);
+  }
+  return memoizedAddressTableLookupEncoder;
+}
+var memoizedAddressTableLookupDecoder;
+function getAddressTableLookupDecoder() {
+  if (!memoizedAddressTableLookupDecoder) {
+    memoizedAddressTableLookupDecoder = getStructDecoder([
+      ["lookupTableAddress", getAddressDecoder()],
+      ["writableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
+      ["readableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })]
+    ]);
+  }
+  return memoizedAddressTableLookupDecoder;
+}
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+  if (!memoizedU8Encoder)
+    memoizedU8Encoder = getU8Encoder();
+  return memoizedU8Encoder;
+}
+var memoizedU8Decoder;
+function getMemoizedU8Decoder() {
+  if (!memoizedU8Decoder)
+    memoizedU8Decoder = getU8Decoder();
+  return memoizedU8Decoder;
+}
+function getMessageHeaderEncoder() {
+  return getStructEncoder([
+    ["numSignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
+  ]);
+}
+function getMessageHeaderDecoder() {
+  return getStructDecoder([
+    ["numSignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Decoder()]
+  ]);
+}
+var memoizedGetInstructionEncoder;
+function getInstructionEncoder() {
+  if (!memoizedGetInstructionEncoder) {
+    memoizedGetInstructionEncoder = mapEncoder(
+      getStructEncoder([
+        ["programAddressIndex", getU8Encoder()],
+        ["accountIndices", getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })],
+        ["data", getBytesEncoder({ size: 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 = mapDecoder(
+      getStructDecoder([
+        ["programAddressIndex", getU8Decoder()],
+        ["accountIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
+        ["data", getBytesDecoder({ size: 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 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 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 getStructEncoder(getPreludeStructEncoderTuple());
+}
+function getCompiledMessageVersionedEncoder() {
+  return mapEncoder(
+    getStructEncoder([
+      ...getPreludeStructEncoderTuple(),
+      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
+    ]),
+    (value) => {
+      if (value.version === "legacy") {
+        return value;
+      }
+      return {
+        ...value,
+        addressTableLookups: value.addressTableLookups ?? []
+      };
+    }
+  );
+}
+function getPreludeStructEncoderTuple() {
+  return [
+    ["version", getTransactionVersionEncoder()],
+    ["header", getMessageHeaderEncoder()],
+    ["staticAccounts", getArrayEncoder(getAddressEncoder(), { size: getShortU16Encoder() })],
+    ["lifetimeToken", getStringEncoder({ encoding: getBase58Encoder(), size: 32 })],
+    ["instructions", getArrayEncoder(getInstructionEncoder(), { size: getShortU16Encoder() })]
+  ];
+}
+function getPreludeStructDecoderTuple() {
+  return [
+    ["version", getTransactionVersionDecoder()],
+    ["header", getMessageHeaderDecoder()],
+    ["staticAccounts", getArrayDecoder(getAddressDecoder(), { size: getShortU16Decoder() })],
+    ["lifetimeToken", getStringDecoder({ encoding: getBase58Decoder(), size: 32 })],
+    ["instructions", getArrayDecoder(getInstructionDecoder(), { size: getShortU16Decoder() })],
+    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
+  ];
+}
+function getAddressTableLookupArrayEncoder() {
+  return getArrayEncoder(getAddressTableLookupEncoder(), { size: getShortU16Encoder() });
+}
+function getAddressTableLookupArrayDecoder() {
+  return getArrayDecoder(getAddressTableLookupDecoder(), { size: getShortU16Decoder() });
+}
+function getCompiledMessageEncoder() {
+  return 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 mapDecoder(getStructDecoder(getPreludeStructDecoderTuple()), ({ addressTableLookups, ...restOfMessage }) => {
+    if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+      return restOfMessage;
+    }
+    return { ...restOfMessage, addressTableLookups };
+  });
+}
+function getCompiledMessageCodec() {
+  return combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
+}
 
 // src/compile-transaction.ts
 function getCompiledTransaction(transaction) {
@@ -594,380 +818,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 = getStructEncoder(
-      [
-        ["lookupTableAddress", getAddressEncoder({ description: lookupTableAddressDescription })],
-        [
-          "writableIndices",
-          getArrayEncoder(getU8Encoder(), {
-            description: writableIndicesDescription,
-            size: getShortU16Encoder()
-          })
-        ],
-        [
-          "readableIndices",
-          getArrayEncoder(getU8Encoder(), {
-            description: readableIndicesDescription,
-            size: getShortU16Encoder()
-          })
-        ]
-      ],
-      { description: addressTableLookupDescription }
-    );
-  }
-  return memoizedAddressTableLookupEncoder;
-}
-var memoizedAddressTableLookupDecoder;
-function getAddressTableLookupDecoder() {
-  if (!memoizedAddressTableLookupDecoder) {
-    memoizedAddressTableLookupDecoder = getStructDecoder(
-      [
-        ["lookupTableAddress", getAddressDecoder({ description: lookupTableAddressDescription })],
-        [
-          "writableIndices",
-          getArrayDecoder(getU8Decoder(), {
-            description: writableIndicesDescription,
-            size: getShortU16Decoder()
-          })
-        ],
-        [
-          "readableIndices",
-          getArrayDecoder(getU8Decoder(), {
-            description: readableIndicesDescription,
-            size: getShortU16Decoder()
-          })
-        ]
-      ],
-      { description: addressTableLookupDescription }
-    );
-  }
-  return memoizedAddressTableLookupDecoder;
-}
-var memoizedU8Encoder;
-function getMemoizedU8Encoder() {
-  if (!memoizedU8Encoder)
-    memoizedU8Encoder = getU8Encoder();
-  return memoizedU8Encoder;
-}
-function getMemoizedU8EncoderDescription(description) {
-  const encoder = getMemoizedU8Encoder();
-  return {
-    ...encoder,
-    description: description ?? encoder.description
-  };
-}
-var memoizedU8Decoder;
-function getMemoizedU8Decoder() {
-  if (!memoizedU8Decoder)
-    memoizedU8Decoder = 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 getStructEncoder(
-    [
-      ["numSignerAccounts", getMemoizedU8EncoderDescription(numSignerAccountsDescription)],
-      ["numReadonlySignerAccounts", getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)]
-    ],
-    {
-      description: messageHeaderDescription
-    }
-  );
-}
-function getMessageHeaderDecoder() {
-  return 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 = mapEncoder(
-      getStructEncoder([
-        ["programAddressIndex", getU8Encoder({ description: programAddressIndexDescription })],
-        [
-          "accountIndices",
-          getArrayEncoder(getU8Encoder({ description: accountIndexDescription }), {
-            description: accountIndicesDescription,
-            size: getShortU16Encoder()
-          })
-        ],
-        ["data", getBytesEncoder({ description: dataDescription, size: 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 = mapDecoder(
-      getStructDecoder([
-        ["programAddressIndex", getU8Decoder({ description: programAddressIndexDescription })],
-        [
-          "accountIndices",
-          getArrayDecoder(getU8Decoder({ description: accountIndexDescription }), {
-            description: accountIndicesDescription,
-            size: getShortU16Decoder()
-          })
-        ],
-        ["data", getBytesDecoder({ description: dataDescription, size: 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 getStructEncoder(getPreludeStructEncoderTuple());
-}
-function getCompiledMessageVersionedEncoder() {
-  return mapEncoder(
-    getStructEncoder([
-      ...getPreludeStructEncoderTuple(),
-      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
-    ]),
-    (value) => {
-      if (value.version === "legacy") {
-        return value;
-      }
-      return {
-        ...value,
-        addressTableLookups: value.addressTableLookups ?? []
-      };
-    }
-  );
-}
-function getPreludeStructEncoderTuple() {
-  return [
-    ["version", getTransactionVersionEncoder()],
-    ["header", getMessageHeaderEncoder()],
-    [
-      "staticAccounts",
-      getArrayEncoder(getAddressEncoder(), {
-        description: staticAccountsDescription,
-        size: getShortU16Encoder()
-      })
-    ],
-    [
-      "lifetimeToken",
-      getStringEncoder({
-        description: lifetimeTokenDescription,
-        encoding: getBase58Encoder(),
-        size: 32
-      })
-    ],
-    [
-      "instructions",
-      getArrayEncoder(getInstructionEncoder(), {
-        description: instructionsDescription,
-        size: getShortU16Encoder()
-      })
-    ]
-  ];
-}
-function getPreludeStructDecoderTuple() {
-  return [
-    ["version", getTransactionVersionDecoder()],
-    ["header", getMessageHeaderDecoder()],
-    [
-      "staticAccounts",
-      getArrayDecoder(getAddressDecoder(), {
-        description: staticAccountsDescription,
-        size: getShortU16Decoder()
-      })
-    ],
-    [
-      "lifetimeToken",
-      getStringDecoder({
-        description: lifetimeTokenDescription,
-        encoding: getBase58Decoder(),
-        size: 32
-      })
-    ],
-    [
-      "instructions",
-      getArrayDecoder(getInstructionDecoder(), {
-        description: instructionsDescription,
-        size: getShortU16Decoder()
-      })
-    ],
-    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
-  ];
-}
-function getAddressTableLookupArrayEncoder() {
-  return getArrayEncoder(getAddressTableLookupEncoder(), {
-    description: addressTableLookupsDescription,
-    size: getShortU16Encoder()
-  });
-}
-function getAddressTableLookupArrayDecoder() {
-  return getArrayDecoder(getAddressTableLookupDecoder(), {
-    description: addressTableLookupsDescription,
-    size: 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 mapDecoder(
-    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 getStructEncoder(
-    [
-      [
-        "signatures",
-        getArrayEncoder(getBytesEncoder({ size: 64 }), {
-          description: signaturesDescription,
-          size: getShortU16Encoder()
-        })
-      ],
-      ["compiledMessage", getCompiledMessageEncoder()]
-    ],
-    {
-      description: transactionDescription
-    }
-  );
-}
-function getSignatureDecoder() {
-  return mapDecoder(getBytesDecoder({ size: 64 }), (bytes) => bytes);
+  return getStructEncoder([
+    ["signatures", getArrayEncoder(getBytesEncoder({ size: 64 }), { size: getShortU16Encoder() })],
+    ["compiledMessage", getCompiledMessageEncoder()]
+  ]);
 }
 function getCompiledTransactionDecoder() {
-  return getStructDecoder(
+  return getStructDecoder([
     [
-      [
-        "signatures",
-        getArrayDecoder(getSignatureDecoder(), {
-          description: signaturesDescription,
-          size: getShortU16Decoder()
-        })
-      ],
-      ["compiledMessage", getCompiledMessageDecoder()]
+      "signatures",
+      getArrayDecoder(getBytesDecoder({ size: 64 }), {
+        size: getShortU16Decoder()
+      })
     ],
-    {
-      description: transactionDescription
-    }
-  );
+    ["compiledMessage", getCompiledMessageDecoder()]
+  ]);
 }
 function getTransactionEncoder() {
   return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
@@ -981,47 +849,7 @@ function getTransactionDecoder(lastValidBlockHeight) {
 function getTransactionCodec(lastValidBlockHeight) {
   return combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
 }
-var base58Encoder2;
 var base58Decoder;
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  if (!base58Encoder2)
-    base58Encoder2 = getBase58Encoder();
-  try {
-    if (
-      // Lowest value (64 bytes of zeroes)
-      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-      putativeTransactionSignature.length > 88
-    ) {
-      throw new Error("Expected input string to decode to a byte array of length 64.");
-    }
-    const bytes = base58Encoder2.encode(putativeTransactionSignature);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 64) {
-      throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-    }
-  } catch (e) {
-    throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
-      cause: e
-    });
-  }
-}
-function isTransactionSignature(putativeTransactionSignature) {
-  if (!base58Encoder2)
-    base58Encoder2 = getBase58Encoder();
-  if (
-    // Lowest value (64 bytes of zeroes)
-    putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-    putativeTransactionSignature.length > 88
-  ) {
-    return false;
-  }
-  const bytes = base58Encoder2.encode(putativeTransactionSignature);
-  const numBytes = bytes.byteLength;
-  if (numBytes !== 64) {
-    return false;
-  }
-  return true;
-}
 function getSignatureFromTransaction(transaction) {
   if (!base58Decoder)
     base58Decoder = getBase58Decoder();
@@ -1031,10 +859,10 @@ function getSignatureFromTransaction(transaction) {
       "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
     );
   }
-  const transactionSignature2 = base58Decoder.decode(signatureBytes)[0];
-  return transactionSignature2;
+  const transactionSignature = base58Decoder.decode(signatureBytes);
+  return transactionSignature;
 }
-async function signTransaction(keyPairs, transaction) {
+async function partiallySignTransaction(keyPairs, transaction) {
   const compiledMessage = compileMessage(transaction);
   const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
   const wireMessageBytes = getCompiledMessageEncoder().encode(compiledMessage);
@@ -1053,9 +881,11 @@ async function signTransaction(keyPairs, transaction) {
   Object.freeze(out);
   return out;
 }
-function transactionSignature(putativeTransactionSignature) {
-  assertIsTransactionSignature(putativeTransactionSignature);
-  return putativeTransactionSignature;
+async function signTransaction(keyPairs, transaction) {
+  const out = await partiallySignTransaction(keyPairs, transaction);
+  assertTransactionIsFullySigned(out);
+  Object.freeze(out);
+  return out;
 }
 function assertTransactionIsFullySigned(transaction) {
   const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => i.accounts?.filter((a) => isSignerRole(a.role)) ?? []).map((a) => a.address);
@@ -1066,15 +896,11 @@ function assertTransactionIsFullySigned(transaction) {
     }
   });
 }
-
-// src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
   const wireTransactionBytes = getTransactionEncoder().encode(transaction);
-  {
-    return btoa(String.fromCharCode(...wireTransactionBytes));
-  }
+  return getBase64Decoder().decode(wireTransactionBytes);
 }
 
-export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, assertTransactionIsFullySigned, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionCodec, getTransactionDecoder, getTransactionEncoder, isAdvanceNonceAccountInstruction, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };
+export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionWithBlockhashLifetime, assertTransactionIsFullySigned, compileMessage, createTransaction, getBase64EncodedWireTransaction, getCompiledMessageCodec, getCompiledMessageDecoder, getCompiledMessageEncoder, getSignatureFromTransaction, getTransactionCodec, getTransactionDecoder, getTransactionEncoder, isAdvanceNonceAccountInstruction, partiallySignTransaction, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map