@solana/transactions 2.0.0-experimental.8d5318e → 2.0.0-experimental.8e39a42

package/dist/index.browser.js

@@ -1,3 +1,80 @@
+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 { 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';
+
+// ../rpc-types/dist/index.browser.js
+var base58Encoder;
+function assertIsBlockhash(putativeBlockhash) {
+  if (!base58Encoder)
+    base58Encoder = getBase58Encoder();
+  try {
+    if (
+      // Lowest value (32 bytes of zeroes)
+      putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+      putativeBlockhash.length > 44
+    ) {
+      throw new Error("Expected input string to decode to a byte array of length 32.");
+    }
+    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}`);
+    }
+  } catch (e) {
+    throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
+      cause: e
+    });
+  }
+}
+
+// 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;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    lifetimeConstraint: blockhashLifetimeConstraint
+  };
+  Object.freeze(out);
+  return out;
+}
+
 // src/create-transaction.ts
 function createTransaction({
   version
@@ -10,66 +87,860 @@ function createTransaction({
   return out;
 }
 
+// ../instructions/dist/index.browser.js
+var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
+  AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
+  3] = "WRITABLE_SIGNER";
+  AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
+  2] = "READONLY_SIGNER";
+  AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
+  1] = "WRITABLE";
+  AccountRole2[AccountRole2["READONLY"] = /* 0 */
+  0] = "READONLY";
+  return AccountRole2;
+})(AccountRole || {});
+var IS_WRITABLE_BITMASK = 1;
+function isSignerRole(role) {
+  return role >= 2;
+}
+function isWritableRole(role) {
+  return (role & IS_WRITABLE_BITMASK) !== 0;
+}
+function mergeRoles(roleA, roleB) {
+  return roleA | roleB;
+}
+
+// src/durable-nonce.ts
+var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
+var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+function assertIsDurableNonceTransaction(transaction) {
+  if (!isDurableNonceTransaction(transaction)) {
+    throw new Error("Transaction is not a durable nonce transaction");
+  }
+}
+function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
+  return {
+    accounts: [
+      { address: nonceAccountAddress, role: AccountRole.WRITABLE },
+      {
+        address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,
+        role: AccountRole.READONLY
+      },
+      { address: nonceAuthorityAddress, role: AccountRole.READONLY_SIGNER }
+    ],
+    data: new Uint8Array([4, 0, 0, 0]),
+    programAddress: SYSTEM_PROGRAM_ADDRESS
+  };
+}
+function isAdvanceNonceAccountInstruction(instruction) {
+  return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
+  instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
+  instruction.accounts?.length === 3 && // First account is nonce account address
+  instruction.accounts[0].address != null && instruction.accounts[0].role === AccountRole.WRITABLE && // Second account is recent blockhashes sysvar
+  instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS && instruction.accounts[1].role === AccountRole.READONLY && // Third account is nonce authority account
+  instruction.accounts[2].address != null && isSignerRole(instruction.accounts[2].role);
+}
+function isAdvanceNonceAccountInstructionData(data) {
+  return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
+}
+function isDurableNonceTransaction(transaction) {
+  return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
+}
+function isAdvanceNonceAccountInstructionForNonce(instruction, nonceAccountAddress, nonceAuthorityAddress) {
+  return instruction.accounts[0].address === nonceAccountAddress && instruction.accounts[2].address === nonceAuthorityAddress;
+}
+function setTransactionLifetimeUsingDurableNonce({
+  nonce,
+  nonceAccountAddress,
+  nonceAuthorityAddress
+}, transaction) {
+  let newInstructions;
+  const firstInstruction = transaction.instructions[0];
+  if (firstInstruction && isAdvanceNonceAccountInstruction(firstInstruction)) {
+    if (isAdvanceNonceAccountInstructionForNonce(firstInstruction, nonceAccountAddress, nonceAuthorityAddress)) {
+      if (isDurableNonceTransaction(transaction) && transaction.lifetimeConstraint.nonce === nonce) {
+        return transaction;
+      } else {
+        newInstructions = [firstInstruction, ...transaction.instructions.slice(1)];
+      }
+    } else {
+      newInstructions = [
+        createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+        ...transaction.instructions.slice(1)
+      ];
+    }
+  } else {
+    newInstructions = [
+      createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+      ...transaction.instructions
+    ];
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: newInstructions,
+    lifetimeConstraint: {
+      nonce
+    }
+  };
+  Object.freeze(out);
+  return out;
+}
+
 // src/fee-payer.ts
 function setTransactionFeePayer(feePayer, transaction) {
   if ("feePayer" in transaction && feePayer === transaction.feePayer) {
     return transaction;
   }
-  let out;
-  if ("signatures" in transaction) {
-    const {
-      signatures: _,
-      // eslint-disable-line @typescript-eslint/no-unused-vars
-      ...unsignedTransaction
-    } = transaction;
-    out = {
-      ...unsignedTransaction,
-      feePayer
-    };
-  } else {
-    out = {
-      ...transaction,
-      feePayer
-    };
-  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    feePayer
+  };
   Object.freeze(out);
   return out;
 }
 
 // src/instructions.ts
-function replaceInstructions(transaction, nextInstructions) {
-  let out;
-  if ("signatures" in transaction) {
-    const {
-      signatures: _,
-      // eslint-disable-line @typescript-eslint/no-unused-vars
-      ...unsignedTransaction
-    } = transaction;
-    out = {
-      ...unsignedTransaction,
-      instructions: nextInstructions
+function appendTransactionInstruction(instruction, transaction) {
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [...transaction.instructions, instruction]
+  };
+  Object.freeze(out);
+  return out;
+}
+function prependTransactionInstruction(instruction, transaction) {
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [instruction, ...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 {
-    out = {
-      ...transaction,
-      instructions: nextInstructions
+    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 });
+}
+var TYPE = Symbol("AddressMapTypeProperty");
+function getAddressMapFromInstructions(feePayer, instructions) {
+  const addressMap = {
+    [feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
+  };
+  const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
+  for (const instruction of instructions) {
+    upsert(addressMap, instruction.programAddress, (entry) => {
+      addressesOfInvokedPrograms.add(instruction.programAddress);
+      if (TYPE in entry) {
+        if (isWritableRole(entry.role)) {
+          switch (entry[TYPE]) {
+            case 0 /* FEE_PAYER */:
+              throw new Error(
+                `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
+              );
+            default:
+              throw new Error(
+                `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
+              );
+          }
+        }
+        if (entry[TYPE] === 2 /* STATIC */) {
+          return entry;
+        }
+      }
+      return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
+    });
+    let addressComparator;
+    if (!instruction.accounts) {
+      continue;
+    }
+    for (const account of instruction.accounts) {
+      upsert(addressMap, account.address, (entry) => {
+        const {
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          address: _,
+          ...accountMeta
+        } = account;
+        if (TYPE in entry) {
+          switch (entry[TYPE]) {
+            case 0 /* FEE_PAYER */:
+              return entry;
+            case 1 /* LOOKUP_TABLE */: {
+              const nextRole = mergeRoles(entry.role, accountMeta.role);
+              if ("lookupTableAddress" in accountMeta) {
+                const shouldReplaceEntry = (
+                  // Consider using the new LOOKUP_TABLE if its address is different...
+                  entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
+                  (addressComparator ||= getAddressComparator())(
+                    accountMeta.lookupTableAddress,
+                    entry.lookupTableAddress
+                  ) < 0
+                );
+                if (shouldReplaceEntry) {
+                  return {
+                    [TYPE]: 1 /* LOOKUP_TABLE */,
+                    ...accountMeta,
+                    role: nextRole
+                  };
+                }
+              } else if (isSignerRole(accountMeta.role)) {
+                return {
+                  [TYPE]: 2 /* STATIC */,
+                  role: nextRole
+                };
+              }
+              if (entry.role !== nextRole) {
+                return {
+                  ...entry,
+                  role: nextRole
+                };
+              } else {
+                return entry;
+              }
+            }
+            case 2 /* STATIC */: {
+              const nextRole = mergeRoles(entry.role, accountMeta.role);
+              if (
+                // Check to see if this address represents a program that is invoked
+                // in this transaction.
+                addressesOfInvokedPrograms.has(account.address)
+              ) {
+                if (isWritableRole(accountMeta.role)) {
+                  throw new Error(
+                    `This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
+                  );
+                }
+                if (entry.role !== nextRole) {
+                  return {
+                    ...entry,
+                    role: nextRole
+                  };
+                } else {
+                  return entry;
+                }
+              } else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
+              // long as they are not require to sign the transaction.
+              !isSignerRole(entry.role)) {
+                return {
+                  ...accountMeta,
+                  [TYPE]: 1 /* LOOKUP_TABLE */,
+                  role: nextRole
+                };
+              } else {
+                if (entry.role !== nextRole) {
+                  return {
+                    ...entry,
+                    role: nextRole
+                  };
+                } else {
+                  return entry;
+                }
+              }
+            }
+          }
+        }
+        if ("lookupTableAddress" in accountMeta) {
+          return {
+            ...accountMeta,
+            [TYPE]: 1 /* LOOKUP_TABLE */
+          };
+        } else {
+          return {
+            ...accountMeta,
+            [TYPE]: 2 /* STATIC */
+          };
+        }
+      });
+    }
+  }
+  return addressMap;
+}
+function getOrderedAccountsFromAddressMap(addressMap) {
+  let addressComparator;
+  const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
+    if (leftEntry[TYPE] !== rightEntry[TYPE]) {
+      if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
+        return -1;
+      } else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
+        return 1;
+      } else if (leftEntry[TYPE] === 2 /* STATIC */) {
+        return -1;
+      } else if (rightEntry[TYPE] === 2 /* STATIC */) {
+        return 1;
+      }
+    }
+    const leftIsSigner = isSignerRole(leftEntry.role);
+    if (leftIsSigner !== isSignerRole(rightEntry.role)) {
+      return leftIsSigner ? -1 : 1;
+    }
+    const leftIsWritable = isWritableRole(leftEntry.role);
+    if (leftIsWritable !== isWritableRole(rightEntry.role)) {
+      return leftIsWritable ? -1 : 1;
+    }
+    addressComparator ||= getAddressComparator();
+    if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
+      return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
+    } else {
+      return addressComparator(leftAddress, rightAddress);
+    }
+  }).map(([address, addressMeta]) => ({
+    address,
+    ...addressMeta
+  }));
+  return orderedAccounts;
+}
+function getCompiledAddressTableLookups(orderedAccounts) {
+  const index = {};
+  for (const account of orderedAccounts) {
+    if (!("lookupTableAddress" in account)) {
+      continue;
+    }
+    const entry = index[account.lookupTableAddress] ||= {
+      readableIndices: [],
+      writableIndices: []
+    };
+    if (account.role === AccountRole.WRITABLE) {
+      entry.writableIndices.push(account.addressIndex);
+    } else {
+      entry.readableIndices.push(account.addressIndex);
+    }
+  }
+  return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
+    lookupTableAddress,
+    ...index[lookupTableAddress]
+  }));
+}
+
+// src/compile-header.ts
+function getCompiledMessageHeader(orderedAccounts) {
+  let numReadonlyNonSignerAccounts = 0;
+  let numReadonlySignerAccounts = 0;
+  let numSignerAccounts = 0;
+  for (const account of orderedAccounts) {
+    if ("lookupTableAddress" in account) {
+      break;
+    }
+    const accountIsWritable = isWritableRole(account.role);
+    if (isSignerRole(account.role)) {
+      numSignerAccounts++;
+      if (!accountIsWritable) {
+        numReadonlySignerAccounts++;
+      }
+    } else if (!accountIsWritable) {
+      numReadonlyNonSignerAccounts++;
+    }
+  }
+  return {
+    numReadonlyNonSignerAccounts,
+    numReadonlySignerAccounts,
+    numSignerAccounts
+  };
+}
+
+// src/compile-instructions.ts
+function getAccountIndex(orderedAccounts) {
+  const out = {};
+  for (const [index, account] of orderedAccounts.entries()) {
+    out[account.address] = index;
+  }
   return out;
 }
-function appendTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [...transaction.instructions, instruction];
-  const out = replaceInstructions(transaction, nextInstructions);
+function getCompiledInstructions(instructions, orderedAccounts) {
+  const accountIndex = getAccountIndex(orderedAccounts);
+  return instructions.map(({ accounts, data, programAddress }) => {
+    return {
+      programAddressIndex: accountIndex[programAddress],
+      ...accounts ? { accountIndices: accounts.map(({ address }) => accountIndex[address]) } : null,
+      ...data ? { data } : null
+    };
+  });
+}
+
+// src/compile-lifetime-token.ts
+function getCompiledLifetimeToken(lifetimeConstraint) {
+  if ("nonce" in lifetimeConstraint) {
+    return lifetimeConstraint.nonce;
+  }
+  return lifetimeConstraint.blockhash;
+}
+
+// src/compile-static-accounts.ts
+function getCompiledStaticAccounts(orderedAccounts) {
+  const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
+  const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
+  return orderedStaticAccounts.map(({ address }) => address);
+}
+
+// src/message.ts
+function compileMessage(transaction) {
+  const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
+  const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
+  return {
+    ...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
+    header: getCompiledMessageHeader(orderedAccounts),
+    instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
+    lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
+    staticAccounts: getCompiledStaticAccounts(orderedAccounts),
+    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) {
+  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
+  };
+}
+
+// src/serializers/transaction.ts
+function getCompiledTransactionEncoder() {
+  return getStructEncoder([
+    ["signatures", getArrayEncoder(getBytesEncoder({ size: 64 }), { size: getShortU16Encoder() })],
+    ["compiledMessage", getCompiledMessageEncoder()]
+  ]);
+}
+function getCompiledTransactionDecoder() {
+  return getStructDecoder([
+    [
+      "signatures",
+      getArrayDecoder(getBytesDecoder({ size: 64 }), {
+        size: getShortU16Decoder()
+      })
+    ],
+    ["compiledMessage", getCompiledMessageDecoder()]
+  ]);
+}
+function getTransactionEncoder() {
+  return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
+}
+function getTransactionDecoder(config) {
+  return mapDecoder(
+    getCompiledTransactionDecoder(),
+    (compiledTransaction) => decompileTransaction(compiledTransaction, config)
+  );
+}
+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 SolanaError(SOLANA_ERROR__TRANSACTION_SIGNATURE_NOT_COMPUTABLE);
+  }
+  const transactionSignature = base58Decoder.decode(signatureBytes);
+  return transactionSignature;
+}
+async function partiallySignTransaction(keyPairs, transaction) {
+  const compiledMessage = compileMessage(transaction);
+  const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+  const wireMessageBytes = getCompiledMessageEncoder().encode(compiledMessage);
+  const publicKeySignaturePairs = await Promise.all(
+    keyPairs.map(
+      (keyPair) => Promise.all([getAddressFromPublicKey(keyPair.publicKey), signBytes(keyPair.privateKey, wireMessageBytes)])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
+  const out = {
+    ...transaction,
+    signatures: nextSignatures
+  };
   Object.freeze(out);
   return out;
 }
-function prependTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [instruction, ...transaction.instructions];
-  const out = replaceInstructions(transaction, nextInstructions);
+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]) {
+      missingSigs.push(address);
+    }
+  });
+  if (missingSigs.length > 0) {
+    throw new SolanaError(SOLANA_ERROR__TRANSACTION_MISSING_SIGNATURES, {
+      addresses: missingSigs
+    });
+  }
+}
+function getBase64EncodedWireTransaction(transaction) {
+  const wireTransactionBytes = getTransactionEncoder().encode(transaction);
+  return getBase64Decoder().decode(wireTransactionBytes);
+}
 
-export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
+export { appendTransactionInstruction, assertIsDurableNonceTransaction, assertIsTransactionWithBlockhashLifetime, assertTransactionIsFullySigned, compileMessage, createTransaction, decompileTransaction, getBase64EncodedWireTransaction, getCompiledMessageCodec, getCompiledMessageDecoder, getCompiledMessageEncoder, getCompiledTransactionDecoder, getSignatureFromTransaction, getTransactionCodec, getTransactionDecoder, getTransactionEncoder, isAdvanceNonceAccountInstruction, partiallySignTransaction, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.browser.js.map