@solana/transactions 2.0.0-experimental.9bf9fdb → 2.0.0-experimental.9e133fd

package/dist/index.native.js

@@ -1,3 +1,60 @@
+import { base58, struct, array, bytes, shortU16, mapSerializer, string, u8 } from '@metaplex-foundation/umi-serializers';
+import { getAddressFromPublicKey, getAddressComparator, getAddressCodec } from '@solana/addresses';
+import { getStructCodec } from '@solana/codecs-data-structures';
+import { getU8Codec } from '@solana/codecs-numbers';
+import { combineCodec } from '@solana/codecs-core';
+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
+function assertIsBlockhash(putativeBlockhash) {
+  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 bytes3 = base58.serialize(putativeBlockhash);
+    const numBytes = bytes3.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
+    });
+  }
+}
+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 +67,770 @@ 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 && instruction.accounts[2].role === AccountRole.READONLY_SIGNER;
+}
+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 setTransactionLifetimeUsingDurableNonce({
+  nonce,
+  nonceAccountAddress,
+  nonceAuthorityAddress
+}, transaction) {
+  const isAlreadyDurableNonceTransaction = isDurableNonceTransaction(transaction);
+  if (isAlreadyDurableNonceTransaction && transaction.lifetimeConstraint.nonce === nonce && transaction.instructions[0].accounts[0].address === nonceAccountAddress && transaction.instructions[0].accounts[2].address === nonceAuthorityAddress) {
+    return transaction;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [
+      createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
+      ...isAlreadyDurableNonceTransaction ? transaction.instructions.slice(1) : transaction.instructions
+    ],
+    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
-    };
-  } else {
-    out = {
-      ...transaction,
-      instructions: nextInstructions
-    };
-  }
-  return out;
-}
 function appendTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [...transaction.instructions, instruction];
-  const out = replaceInstructions(transaction, nextInstructions);
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [...transaction.instructions, instruction]
+  };
   Object.freeze(out);
   return out;
 }
 function prependTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [instruction, ...transaction.instructions];
-  const out = replaceInstructions(transaction, nextInstructions);
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    instructions: [instruction, ...transaction.instructions]
+  };
+  Object.freeze(out);
+  return out;
+}
+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 || (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 || (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) {
+  var _a;
+  const index = {};
+  for (const account of orderedAccounts) {
+    if (!("lookupTableAddress" in account)) {
+      continue;
+    }
+    const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
+      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 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
+  };
+}
+
+// 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 addressSerializerCompat(compat) {
+  const codec = getAddressCodec();
+  return {
+    description: compat?.description ?? codec.description,
+    deserialize: codec.decode,
+    fixedSize: codec.fixedSize,
+    maxSize: codec.maxSize,
+    serialize: codec.encode
+  };
+}
+function getAddressTableLookupCodec() {
+  return struct(
+    [
+      [
+        "lookupTableAddress",
+        addressSerializerCompat(
+          __DEV__ ? {
+            description: "The address of the address lookup table account from which instruction addresses should be looked up"
+          } : void 0
+        )
+      ],
+      [
+        "writableIndices",
+        array(u8(), {
+          ...__DEV__ ? {
+            description: "The indices of the accounts in the lookup table that should be loaded as writeable"
+          } : null,
+          size: shortU16()
+        })
+      ],
+      [
+        "readableIndices",
+        array(u8(), {
+          ...__DEV__ ? {
+            description: "The indices of the accounts in the lookup table that should be loaded as read-only"
+          } : void 0,
+          size: shortU16()
+        })
+      ]
+    ],
+    __DEV__ ? {
+      description: "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"
+    } : void 0
+  );
+}
+var memoizedU8Codec;
+function getMemoizedU8Codec() {
+  if (!memoizedU8Codec)
+    memoizedU8Codec = getU8Codec();
+  return memoizedU8Codec;
+}
+function getMemoizedU8CodecDescription(description) {
+  const codec = getMemoizedU8Codec();
+  return {
+    ...codec,
+    description: description ?? codec.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 getMessageHeaderCodec() {
+  return getStructCodec(
+    [
+      ["numSignerAccounts", getMemoizedU8CodecDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)]
+    ],
+    {
+      description: messageHeaderDescription
+    }
+  );
+}
+function getInstructionCodec() {
+  return mapSerializer(
+    struct([
+      [
+        "programAddressIndex",
+        u8(
+          __DEV__ ? {
+            description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
+          } : void 0
+        )
+      ],
+      [
+        "accountIndices",
+        array(
+          u8({
+            description: __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : ""
+          }),
+          {
+            description: __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" : "",
+            size: shortU16()
+          }
+        )
+      ],
+      [
+        "data",
+        bytes({
+          description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
+          size: shortU16()
+        })
+      ]
+    ]),
+    (value) => {
+      if (value.accountIndices !== void 0 && value.data !== void 0) {
+        return value;
+      }
+      return {
+        ...value,
+        accountIndices: value.accountIndices ?? [],
+        data: value.data ?? new Uint8Array(0)
+      };
+    },
+    (value) => {
+      if (value.accountIndices.length && value.data.byteLength) {
+        return value;
+      }
+      const { accountIndices, data, ...rest } = value;
+      return {
+        ...rest,
+        ...accountIndices.length ? { accountIndices } : null,
+        ...data.byteLength ? { data } : null
+      };
+    }
+  );
+}
+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(bytes3, offset = 0) {
+  const firstByte = bytes3[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
+  };
+}
+function getTransactionVersionCodec() {
+  return combineCodec(getTransactionVersionEncoder(), getTransactionVersionDecoder());
+}
+
+// src/serializers/unimplemented.ts
+function getError(type, name) {
+  const functionSuffix = name + type[0].toUpperCase() + type.slice(1);
+  return new Error(
+    `No ${type} exists for ${name}. Use \`get${functionSuffix}()\` if you need a ${type}, and \`get${name}Codec()\` if you need to both encode and decode ${name}`
+  );
+}
+function getUnimplementedDecoder(name) {
+  return () => {
+    throw getError("decoder", name);
+  };
+}
+
+// src/serializers/message.ts
+var BASE_CONFIG2 = {
+  description: __DEV__ ? "The wire format of a Solana transaction message" : "",
+  fixedSize: null,
+  maxSize: null
+};
+function serialize(compiledMessage) {
+  if (compiledMessage.version === "legacy") {
+    return struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
+  } else {
+    return mapSerializer(
+      struct([
+        ...getPreludeStructSerializerTuple(),
+        ["addressTableLookups", getAddressTableLookupsSerializer()]
+      ]),
+      (value) => {
+        if (value.version === "legacy") {
+          return value;
+        }
+        return {
+          ...value,
+          addressTableLookups: value.addressTableLookups ?? []
+        };
+      }
+    ).serialize(compiledMessage);
+  }
+}
+function toSerializer(codec) {
+  return {
+    description: codec.description,
+    deserialize: codec.decode,
+    fixedSize: codec.fixedSize,
+    maxSize: codec.maxSize,
+    serialize: codec.encode
+  };
+}
+function getPreludeStructSerializerTuple() {
+  return [
+    ["version", toSerializer(getTransactionVersionCodec())],
+    ["header", toSerializer(getMessageHeaderCodec())],
+    [
+      "staticAccounts",
+      array(toSerializer(getAddressCodec()), {
+        description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
+        size: shortU16()
+      })
+    ],
+    [
+      "lifetimeToken",
+      string({
+        description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
+        encoding: base58,
+        size: 32
+      })
+    ],
+    [
+      "instructions",
+      array(getInstructionCodec(), {
+        description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
+        size: shortU16()
+      })
+    ]
+  ];
+}
+function getAddressTableLookupsSerializer() {
+  return array(getAddressTableLookupCodec(), {
+    ...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
+    size: shortU16()
+  });
+}
+function getCompiledMessageEncoder() {
+  return {
+    ...BASE_CONFIG2,
+    deserialize: getUnimplementedDecoder("CompiledMessage"),
+    serialize
+  };
+}
+
+// src/serializers/transaction.ts
+var BASE_CONFIG3 = {
+  description: __DEV__ ? "The wire format of a Solana transaction" : "",
+  fixedSize: null,
+  maxSize: null
+};
+function serialize2(transaction) {
+  const compiledTransaction = getCompiledTransaction(transaction);
+  return struct([
+    [
+      "signatures",
+      array(bytes({ size: 64 }), {
+        ...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
+        size: shortU16()
+      })
+    ],
+    ["compiledMessage", getCompiledMessageEncoder()]
+  ]).serialize(compiledTransaction);
+}
+function getTransactionEncoder() {
+  return {
+    ...BASE_CONFIG3,
+    deserialize: getUnimplementedDecoder("CompiledMessage"),
+    serialize: serialize2
+  };
+}
+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 bytes3 = base58.serialize(putativeTransactionSignature);
+    const numBytes = bytes3.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 bytes3 = base58.serialize(putativeTransactionSignature);
+  const numBytes = bytes3.byteLength;
+  if (numBytes !== 64) {
+    return false;
+  }
+  return true;
+}
+async function getCompiledMessageSignature(message, secretKey) {
+  const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
+  const signature = await signBytes(secretKey, wireMessageBytes);
+  return signature;
+}
+function getSignatureFromTransaction(transaction) {
+  const signature = transaction.signatures[transaction.feePayer];
+  if (!signature) {
+    throw new Error(
+      "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
+    );
+  }
+  return signature;
+}
+async function signTransaction(keyPairs, transaction) {
+  const compiledMessage = compileMessage(transaction);
+  const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
+  const publicKeySignaturePairs = await Promise.all(
+    keyPairs.map(
+      (keyPair) => Promise.all([
+        getAddressFromPublicKey(keyPair.publicKey),
+        getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
+      ])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
+  const out = {
+    ...transaction,
+    signatures: nextSignatures
+  };
   Object.freeze(out);
   return out;
 }
+function transactionSignature(putativeTransactionSignature) {
+  assertIsTransactionSignature(putativeTransactionSignature);
+  return putativeTransactionSignature;
+}
+
+// src/wire-transaction.ts
+function getBase64EncodedWireTransaction(transaction) {
+  const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
+  {
+    return btoa(String.fromCharCode(...wireTransactionBytes));
+  }
+}
 
-export { appendTransactionInstruction, createTransaction, prependTransactionInstruction, setTransactionFeePayer };
+export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionEncoder, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map