@solana/transactions 2.0.0-experimental.cf6ca9d → 2.0.0-experimental.d06660c

package/dist/index.browser.js

@@ -1,31 +1,17 @@
-import { base58 } from '@metaplex-foundation/umi-serializers';
-import { mapEncoder, mapDecoder, combineCodec } from '@solana/codecs-core';
-import { getStructEncoder, getArrayEncoder, getBytesEncoder, getStructDecoder, getArrayDecoder, 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 { getBase58Decoder, getBase64Decoder, getStringEncoder, getBase58Encoder, getStringDecoder } from '@solana/codecs-strings';
+import { getAddressFromPublicKey, assertIsAddress, getAddressComparator, getAddressEncoder, getAddressDecoder } from '@solana/addresses';
 import { pipe } from '@solana/functional';
-import { getStringEncoder, getBase58Encoder, getStringDecoder, getBase58Decoder } from '@solana/codecs-strings';
+import { createEncoder, mapDecoder, combineCodec, mapEncoder, createDecoder } from '@solana/codecs-core';
+import { getStructDecoder, getArrayDecoder, getBytesDecoder, getStructEncoder, getArrayEncoder, getBytesEncoder } from '@solana/codecs-data-structures';
+import { getShortU16Decoder, getShortU16Encoder, getU8Encoder, getU8Decoder } from '@solana/codecs-numbers';
+import { SolanaError, SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE, SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES } from '@solana/errors';
 import { signBytes } from '@solana/keys';
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-
-// src/unsigned-transaction.ts
-function getUnsignedTransaction(transaction) {
-  if ("signatures" in transaction) {
-    const {
-      signatures: _,
-      // eslint-disable-line @typescript-eslint/no-unused-vars
-      ...unsignedTransaction
-    } = transaction;
-    return unsignedTransaction;
-  } else {
-    return transaction;
-  }
-}
-
-// src/blockhash.ts
+// ../rpc-types/dist/index.browser.js
+var base58Encoder;
 function assertIsBlockhash(putativeBlockhash) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
   try {
     if (
       // Lowest value (32 bytes of zeroes)
@@ -34,7 +20,7 @@ function assertIsBlockhash(putativeBlockhash) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 32.");
     }
-    const bytes = base58.serialize(putativeBlockhash);
+    const bytes = base58Encoder.encode(putativeBlockhash);
     const numBytes = bytes.byteLength;
     if (numBytes !== 32) {
       throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
@@ -45,6 +31,38 @@ function assertIsBlockhash(putativeBlockhash) {
     });
   }
 }
+
+// src/unsigned-transaction.ts
+function getUnsignedTransaction(transaction) {
+  if ("signatures" in transaction) {
+    const {
+      signatures: _,
+      // eslint-disable-line @typescript-eslint/no-unused-vars
+      ...unsignedTransaction
+    } = transaction;
+    return unsignedTransaction;
+  } else {
+    return transaction;
+  }
+}
+
+// src/blockhash.ts
+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;
@@ -183,21 +201,172 @@ function setTransactionFeePayer(feePayer, transaction) {
 
 // src/instructions.ts
 function appendTransactionInstruction(instruction, transaction) {
+  return appendTransactionInstructions([instruction], transaction);
+}
+function appendTransactionInstructions(instructions, transaction) {
   const out = {
     ...getUnsignedTransaction(transaction),
-    instructions: [...transaction.instructions, instruction]
+    instructions: [...transaction.instructions, ...instructions]
   };
   Object.freeze(out);
   return out;
 }
 function prependTransactionInstruction(instruction, transaction) {
+  return prependTransactionInstructions([instruction], transaction);
+}
+function prependTransactionInstructions(instructions, transaction) {
   const out = {
     ...getUnsignedTransaction(transaction),
-    instructions: [instruction, ...transaction.instructions]
+    instructions: [...instructions, ...transaction.instructions]
   };
   Object.freeze(out);
   return out;
 }
+
+// src/decompile-transaction.ts
+function getAccountMetas(message) {
+  const { header } = message;
+  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
+  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
+  const accountMetas = [];
+  let accountIndex = 0;
+  for (let i = 0; i < numWritableSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY_SIGNER
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.WRITABLE
+    });
+    accountIndex++;
+  }
+  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
+    accountMetas.push({
+      address: message.staticAccounts[accountIndex],
+      role: AccountRole.READONLY
+    });
+    accountIndex++;
+  }
+  return accountMetas;
+}
+function getAddressLookupMetas(compiledAddressTableLookups, addressesByLookupTableAddress) {
+  const compiledAddressTableLookupAddresses = compiledAddressTableLookups.map((l) => l.lookupTableAddress);
+  const missing = compiledAddressTableLookupAddresses.filter((a) => addressesByLookupTableAddress[a] === void 0);
+  if (missing.length > 0) {
+    const missingAddresses = missing.join(", ");
+    throw new Error(`Addresses not provided for lookup tables: [${missingAddresses}]`);
+  }
+  const readOnlyMetas = [];
+  const writableMetas = [];
+  for (const lookup of compiledAddressTableLookups) {
+    const addresses = addressesByLookupTableAddress[lookup.lookupTableAddress];
+    const highestIndex = Math.max(...lookup.readableIndices, ...lookup.writableIndices);
+    if (highestIndex >= addresses.length) {
+      throw new Error(
+        `Cannot look up index ${highestIndex} in lookup table [${lookup.lookupTableAddress}]. The lookup table may have been extended since the addresses provided were retrieved.`
+      );
+    }
+    const readOnlyForLookup = lookup.readableIndices.map((r) => ({
+      address: addresses[r],
+      addressIndex: r,
+      lookupTableAddress: lookup.lookupTableAddress,
+      role: AccountRole.READONLY
+    }));
+    readOnlyMetas.push(...readOnlyForLookup);
+    const writableForLookup = lookup.writableIndices.map((w) => ({
+      address: addresses[w],
+      addressIndex: w,
+      lookupTableAddress: lookup.lookupTableAddress,
+      role: AccountRole.WRITABLE
+    }));
+    writableMetas.push(...writableForLookup);
+  }
+  return [...writableMetas, ...readOnlyMetas];
+}
+function convertInstruction(instruction, accountMetas) {
+  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
+  if (!programAddress) {
+    throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
+  }
+  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
+  const { data } = instruction;
+  return {
+    programAddress,
+    ...accounts && accounts.length ? { accounts } : {},
+    ...data && data.length ? { data } : {}
+  };
+}
+function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
+  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
+    return {
+      blockhash: messageLifetimeToken,
+      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
+      // U64 MAX
+    };
+  } else {
+    const nonceAccountAddress = firstInstruction.accounts[0].address;
+    assertIsAddress(nonceAccountAddress);
+    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
+    assertIsAddress(nonceAuthorityAddress);
+    return {
+      nonce: messageLifetimeToken,
+      nonceAccountAddress,
+      nonceAuthorityAddress
+    };
+  }
+}
+function convertSignatures(compiledTransaction) {
+  const {
+    compiledMessage: { staticAccounts },
+    signatures
+  } = compiledTransaction;
+  return signatures.reduce((acc, sig, index) => {
+    const allZeros = sig.every((byte) => byte === 0);
+    if (allZeros)
+      return acc;
+    const address = staticAccounts[index];
+    return { ...acc, [address]: sig };
+  }, {});
+}
+function decompileTransaction(compiledTransaction, config) {
+  const { compiledMessage } = compiledTransaction;
+  const feePayer = compiledMessage.staticAccounts[0];
+  if (!feePayer)
+    throw new Error("No fee payer set in CompiledTransaction");
+  const accountMetas = getAccountMetas(compiledMessage);
+  const accountLookupMetas = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? getAddressLookupMetas(compiledMessage.addressTableLookups, config?.addressesByLookupTableAddress ?? {}) : [];
+  const transactionMetas = [...accountMetas, ...accountLookupMetas];
+  const instructions = compiledMessage.instructions.map(
+    (compiledInstruction) => convertInstruction(compiledInstruction, transactionMetas)
+  );
+  const firstInstruction = instructions[0];
+  const lifetimeConstraint = getLifetimeConstraint(
+    compiledMessage.lifetimeToken,
+    firstInstruction,
+    config?.lastValidBlockHeight
+  );
+  const signatures = convertSignatures(compiledTransaction);
+  return pipe(
+    createTransaction({ version: compiledMessage.version }),
+    (tx) => setTransactionFeePayer(feePayer, tx),
+    (tx) => instructions.reduce((acc, instruction) => {
+      return appendTransactionInstruction(instruction, acc);
+    }, tx),
+    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
+    (tx) => Object.keys(signatures).length > 0 ? { ...tx, signatures } : tx
+  );
+}
 function upsert(addressMap, address, update) {
   addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
 }
@@ -250,7 +419,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
@@ -356,7 +525,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 {
@@ -369,16 +538,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 {
@@ -464,187 +632,31 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
-
-// src/compile-transaction.ts
-function getCompiledTransaction(transaction) {
-  const compiledMessage = compileMessage(transaction);
-  let signatures;
-  if ("signatures" in transaction) {
-    signatures = [];
-    for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
-      signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
-    }
-  } else {
-    signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
-  }
-  return {
-    compiledMessage,
-    signatures
-  };
-}
-function getAccountMetas(message) {
-  const { header } = message;
-  const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
-  const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
-  const accountMetas = [];
-  let accountIndex = 0;
-  for (let i = 0; i < numWritableSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY_SIGNER
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < numWritableNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.WRITABLE
-    });
-    accountIndex++;
-  }
-  for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
-    accountMetas.push({
-      address: message.staticAccounts[accountIndex],
-      role: AccountRole.READONLY
-    });
-    accountIndex++;
-  }
-  return accountMetas;
-}
-function convertInstruction(instruction, accountMetas) {
-  const programAddress = accountMetas[instruction.programAddressIndex]?.address;
-  if (!programAddress) {
-    throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
-  }
-  const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
-  const { data } = instruction;
-  return {
-    programAddress,
-    ...accounts && accounts.length ? { accounts } : {},
-    ...data && data.length ? { data } : {}
-  };
-}
-function getLifetimeConstraint(messageLifetimeToken, firstInstruction, lastValidBlockHeight) {
-  if (!firstInstruction || !isAdvanceNonceAccountInstruction(firstInstruction)) {
-    return {
-      blockhash: messageLifetimeToken,
-      lastValidBlockHeight: lastValidBlockHeight ?? 2n ** 64n - 1n
-      // U64 MAX
-    };
-  } else {
-    const nonceAccountAddress = firstInstruction.accounts[0].address;
-    assertIsAddress(nonceAccountAddress);
-    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
-    assertIsAddress(nonceAuthorityAddress);
-    return {
-      nonce: messageLifetimeToken,
-      nonceAccountAddress,
-      nonceAuthorityAddress
-    };
-  }
-}
-function convertSignatures(compiledTransaction) {
-  const {
-    compiledMessage: { staticAccounts },
-    signatures
-  } = compiledTransaction;
-  return signatures.reduce((acc, sig, index) => {
-    const allZeros = sig.every((byte) => byte === 0);
-    if (allZeros)
-      return acc;
-    const address = staticAccounts[index];
-    return { ...acc, [address]: sig };
-  }, {});
-}
-function decompileTransaction(compiledTransaction, lastValidBlockHeight) {
-  const { compiledMessage } = compiledTransaction;
-  if ("addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups.length > 0) {
-    throw new Error("Cannot convert transaction with addressTableLookups");
-  }
-  const feePayer = compiledMessage.staticAccounts[0];
-  if (!feePayer)
-    throw new Error("No fee payer set in CompiledTransaction");
-  const accountMetas = getAccountMetas(compiledMessage);
-  const instructions = compiledMessage.instructions.map(
-    (compiledInstruction) => convertInstruction(compiledInstruction, accountMetas)
-  );
-  const firstInstruction = instructions[0];
-  const lifetimeConstraint = getLifetimeConstraint(
-    compiledMessage.lifetimeToken,
-    firstInstruction,
-    lastValidBlockHeight
-  );
-  const signatures = convertSignatures(compiledTransaction);
-  return pipe(
-    createTransaction({ version: compiledMessage.version }),
-    (tx) => setTransactionFeePayer(feePayer, tx),
-    (tx) => instructions.reduce((acc, instruction) => {
-      return appendTransactionInstruction(instruction, acc);
-    }, tx),
-    (tx) => "blockhash" in lifetimeConstraint ? setTransactionLifetimeUsingBlockhash(lifetimeConstraint, tx) : setTransactionLifetimeUsingDurableNonce(lifetimeConstraint, tx),
-    (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(
+    memoizedAddressTableLookupEncoder = getStructEncoder([
+      ["lookupTableAddress", getAddressEncoder()],
       [
-        ["lookupTableAddress", getAddressEncoder({ description: lookupTableAddressDescription })],
-        [
-          "writableIndices",
-          getArrayEncoder(getU8Encoder(), {
-            description: writableIndicesDescription,
-            size: getShortU16Encoder()
-          })
-        ],
-        [
-          "readableIndices",
-          getArrayEncoder(getU8Encoder(), {
-            description: readableIndicesDescription,
-            size: getShortU16Encoder()
-          })
-        ]
+        "writableIndices",
+        getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
       ],
-      { description: addressTableLookupDescription }
-    );
+      [
+        "readableIndices",
+        getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
+      ]
+    ]);
   }
   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 }
-    );
+    memoizedAddressTableLookupDecoder = getStructDecoder([
+      ["lookupTableAddress", getAddressDecoder()],
+      ["writableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
+      ["readableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })]
+    ]);
   }
   return memoizedAddressTableLookupDecoder;
 }
@@ -654,72 +666,34 @@ function getMemoizedU8Encoder() {
     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
-    }
-  );
+  return getStructEncoder([
+    ["numSignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Encoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
+  ]);
 }
 function getMessageHeaderDecoder() {
-  return getStructDecoder(
-    [
-      ["numSignerAccounts", getMemoizedU8DecoderDescription(numSignerAccountsDescription)],
-      ["numReadonlySignerAccounts", getMemoizedU8DecoderDescription(numReadonlySignerAccountsDescription)],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8DecoderDescription(numReadonlyNonSignerAccountsDescription)]
-    ],
-    {
-      description: messageHeaderDescription
-    }
-  );
+  return getStructDecoder([
+    ["numSignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlySignerAccounts", getMemoizedU8Decoder()],
+    ["numReadonlyNonSignerAccounts", getMemoizedU8Decoder()]
+  ]);
 }
-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() })]
+        ["programAddressIndex", getU8Encoder()],
+        ["accountIndices", getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })],
+        ["data", getBytesEncoder({ size: getShortU16Encoder() })]
       ]),
       // Convert an instruction to have all fields defined
       (instruction) => {
@@ -741,15 +715,9 @@ 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() })]
+        ["programAddressIndex", getU8Decoder()],
+        ["accountIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
+        ["data", getBytesDecoder({ size: getShortU16Decoder() })]
       ]),
       // Convert an instruction to exclude optional fields if they are empty
       (instruction) => {
@@ -768,47 +736,38 @@ function getInstructionDecoder() {
   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 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 {
-    ...BASE_CONFIG,
-    decode
-  };
-}
-function getTransactionVersionEncoder() {
-  return {
-    ...BASE_CONFIG,
-    encode
-  };
+  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
-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());
 }
@@ -833,91 +792,48 @@ 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()
-      })
-    ]
+    ["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(), {
-        description: staticAccountsDescription,
-        size: getShortU16Decoder()
-      })
-    ],
-    [
-      "lifetimeToken",
-      getStringDecoder({
-        description: lifetimeTokenDescription,
-        encoding: getBase58Decoder(),
-        size: 32
-      })
-    ],
-    [
-      "instructions",
-      getArrayDecoder(getInstructionDecoder(), {
-        description: instructionsDescription,
-        size: getShortU16Decoder()
-      })
-    ],
+    ["staticAccounts", getArrayDecoder(getAddressDecoder(), { size: getShortU16Decoder() })],
+    ["lifetimeToken", getStringDecoder({ encoding: getBase58Decoder(), size: 32 })],
+    ["instructions", getArrayDecoder(getInstructionDecoder(), { size: getShortU16Decoder() })],
     ["addressTableLookups", getAddressTableLookupArrayDecoder()]
   ];
 }
 function getAddressTableLookupArrayEncoder() {
-  return getArrayEncoder(getAddressTableLookupEncoder(), {
-    description: addressTableLookupsDescription,
-    size: getShortU16Encoder()
-  });
+  return getArrayEncoder(getAddressTableLookupEncoder(), { size: getShortU16Encoder() });
 }
 function getAddressTableLookupArrayDecoder() {
-  return getArrayDecoder(getAddressTableLookupDecoder(), {
-    description: addressTableLookupsDescription,
-    size: getShortU16Decoder()
-  });
+  return getArrayDecoder(getAddressTableLookupDecoder(), { size: getShortU16Decoder() });
 }
-var messageDescription = __DEV__ ? "The wire format of a Solana transaction message" : "message";
 function getCompiledMessageEncoder() {
-  return {
-    description: messageDescription,
-    encode: (compiledMessage) => {
+  return createEncoder({
+    getSizeFromValue: (compiledMessage) => {
       if (compiledMessage.version === "legacy") {
-        return getCompiledMessageLegacyEncoder().encode(compiledMessage);
+        return getCompiledMessageLegacyEncoder().getSizeFromValue(compiledMessage);
       } else {
-        return getCompiledMessageVersionedEncoder().encode(compiledMessage);
+        return getCompiledMessageVersionedEncoder().getSizeFromValue(compiledMessage);
       }
     },
-    fixedSize: null,
-    maxSize: null
-  };
+    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(), {
-      description: messageDescription
-    }),
+    getStructDecoder(getPreludeStructDecoderTuple()),
     ({ addressTableLookups, ...restOfMessage }) => {
       if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
         return restOfMessage;
@@ -926,105 +842,70 @@ function getCompiledMessageDecoder() {
     }
   );
 }
+function getCompiledMessageCodec() {
+  return combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
+}
 
-// 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
+// src/compile-transaction.ts
+function getCompiledTransaction(transaction) {
+  const compiledMessage = compileMessage(transaction);
+  let signatures;
+  if ("signatures" in transaction) {
+    signatures = [];
+    for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
+      signatures[ii] = transaction.signatures[compiledMessage.staticAccounts[ii]] ?? new Uint8Array(Array(64).fill(0));
     }
-  );
+  } else {
+    signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
+  }
+  return {
+    compiledMessage,
+    signatures
+  };
 }
-function getSignatureDecoder() {
-  return mapDecoder(getBytesDecoder({ size: 64 }), (bytes) => bytes);
+
+// src/serializers/transaction.ts
+function getCompiledTransactionEncoder() {
+  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);
 }
-function getTransactionDecoder(lastValidBlockHeight) {
+function getTransactionDecoder(config) {
   return mapDecoder(
     getCompiledTransactionDecoder(),
-    (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
+    (compiledTransaction) => decompileTransaction(compiledTransaction, config)
   );
 }
-function getTransactionCodec(lastValidBlockHeight) {
-  return combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
-}
-function assertIsTransactionSignature(putativeTransactionSignature) {
-  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 = base58.serialize(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 (
-    // Lowest value (64 bytes of zeroes)
-    putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-    putativeTransactionSignature.length > 88
-  ) {
-    return false;
-  }
-  const bytes = base58.serialize(putativeTransactionSignature);
-  const numBytes = bytes.byteLength;
-  if (numBytes !== 64) {
-    return false;
-  }
-  return true;
+function getTransactionCodec(config) {
+  return combineCodec(getTransactionEncoder(), getTransactionDecoder(config));
 }
+var base58Decoder;
 function getSignatureFromTransaction(transaction) {
+  if (!base58Decoder)
+    base58Decoder = getBase58Decoder();
   const signatureBytes = transaction.signatures[transaction.feePayer];
   if (!signatureBytes) {
-    throw new Error(
-      "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
-    );
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE);
   }
-  const transactionSignature2 = base58.deserialize(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);
@@ -1043,28 +924,32 @@ 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);
   const requiredSigners = /* @__PURE__ */ new Set([transaction.feePayer, ...signerAddressesFromInstructions]);
+  const missingSigs = [];
   requiredSigners.forEach((address) => {
     if (!transaction.signatures[address]) {
-      throw new Error(`Transaction is missing signature for address \`${address}\``);
+      missingSigs.push(address);
     }
   });
+  if (missingSigs.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES, {
+      addresses: missingSigs
+    });
+  }
 }
-
-// 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, appendTransactionInstructions, assertIsDurableNonceTransaction, assertIsTransactionWithBlockhashLifetime, assertTransactionIsFullySigned, compileMessage, createTransaction, decompileTransaction, getBase64EncodedWireTransaction, getCompiledMessageCodec, getCompiledMessageDecoder, getCompiledMessageEncoder, getCompiledTransactionDecoder, getSignatureFromTransaction, getTransactionCodec, getTransactionDecoder, getTransactionEncoder, getUnsignedTransaction, isAdvanceNonceAccountInstruction, partiallySignTransaction, prependTransactionInstruction, prependTransactionInstructions, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map