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

package/dist/index.native.js

@@ -1,8 +1,10 @@
-import { base58, struct, array, bytes, shortU16, mapSerializer, string } from '@metaplex-foundation/umi-serializers';
-import { getAddressFromPublicKey, getAddressComparator, getAddressCodec, getAddressEncoder, getAddressDecoder } from '@solana/addresses';
-import { combineCodec, mapEncoder, mapDecoder } from '@solana/codecs-core';
-import { getStructCodec, getStructEncoder, getArrayEncoder, getStructDecoder, getArrayDecoder, getBytesEncoder, getBytesDecoder } from '@solana/codecs-data-structures';
-import { getU8Encoder, getShortU16Encoder, getU8Decoder, getShortU16Decoder, getU8Codec } from '@solana/codecs-numbers';
+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 { pipe } from '@solana/functional';
+import { getStringEncoder, getBase58Encoder, getStringDecoder, getBase58Decoder } from '@solana/codecs-strings';
 import { signBytes } from '@solana/keys';
 
 // ../build-scripts/env-shim.ts
@@ -32,8 +34,8 @@ function assertIsBlockhash(putativeBlockhash) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 32.");
     }
-    const bytes2 = base58.serialize(putativeBlockhash);
-    const numBytes = bytes2.byteLength;
+    const bytes = base58.serialize(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}`);
     }
@@ -118,7 +120,7 @@ function isAdvanceNonceAccountInstruction(instruction) {
   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;
+  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;
@@ -126,21 +128,38 @@ function isAdvanceNonceAccountInstructionData(data) {
 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) {
-  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;
+  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: [
-      createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
-      ...isAlreadyDurableNonceTransaction ? transaction.instructions.slice(1) : transaction.instructions
-    ],
+    instructions: newInstructions,
     lifetimeConstraint: {
       nonce
     }
@@ -463,6 +482,116 @@ function getCompiledTransaction(transaction) {
     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";
@@ -519,32 +648,54 @@ function getAddressTableLookupDecoder() {
   }
   return memoizedAddressTableLookupDecoder;
 }
-function getAddressTableLookupCodec() {
-  return combineCodec(getAddressTableLookupEncoder(), getAddressTableLookupDecoder());
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+  if (!memoizedU8Encoder)
+    memoizedU8Encoder = getU8Encoder();
+  return memoizedU8Encoder;
 }
-var memoizedU8Codec;
-function getMemoizedU8Codec() {
-  if (!memoizedU8Codec)
-    memoizedU8Codec = getU8Codec();
-  return memoizedU8Codec;
+function getMemoizedU8EncoderDescription(description) {
+  const encoder = getMemoizedU8Encoder();
+  return {
+    ...encoder,
+    description: description ?? encoder.description
+  };
+}
+var memoizedU8Decoder;
+function getMemoizedU8Decoder() {
+  if (!memoizedU8Decoder)
+    memoizedU8Decoder = getU8Decoder();
+  return memoizedU8Decoder;
 }
-function getMemoizedU8CodecDescription(description) {
-  const codec = getMemoizedU8Codec();
+function getMemoizedU8DecoderDescription(description) {
+  const decoder = getMemoizedU8Decoder();
   return {
-    ...codec,
-    description: description ?? codec.description
+    ...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 getMessageHeaderCodec() {
-  return getStructCodec(
+function getMessageHeaderEncoder() {
+  return getStructEncoder(
     [
-      ["numSignerAccounts", getMemoizedU8CodecDescription(numSignerAccountsDescription)],
-      ["numReadonlySignerAccounts", getMemoizedU8CodecDescription(numReadonlySignerAccountsDescription)],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8CodecDescription(numReadonlyNonSignerAccountsDescription)]
+      ["numSignerAccounts", getMemoizedU8EncoderDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)]
+    ],
+    {
+      description: messageHeaderDescription
+    }
+  );
+}
+function getMessageHeaderDecoder() {
+  return getStructDecoder(
+    [
+      ["numSignerAccounts", getMemoizedU8DecoderDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8DecoderDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8DecoderDescription(numReadonlyNonSignerAccountsDescription)]
     ],
     {
       description: messageHeaderDescription
@@ -616,17 +767,14 @@ function getInstructionDecoder() {
   }
   return memoizedGetInstructionDecoder;
 }
-function getInstructionCodec() {
-  return combineCodec(getInstructionEncoder(), getInstructionDecoder());
-}
 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(bytes2, offset = 0) {
-  const firstByte = bytes2[offset];
+function decode(bytes, offset = 0) {
+  const firstByte = bytes[offset];
   if ((firstByte & VERSION_FLAG_MASK) === 0) {
     return ["legacy", offset];
   } else {
@@ -655,126 +803,181 @@ function getTransactionVersionEncoder() {
     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);
-  }
+var staticAccountsDescription = __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "staticAccounts";
+var lifetimeTokenDescription = __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "lifetimeToken";
+var instructionsDescription = __DEV__ ? "A compact-array of instructions belonging to this transaction" : "instructions";
+var addressTableLookupsDescription = __DEV__ ? "A compact array of address table lookups belonging to this transaction" : "addressTableLookups";
+function getCompiledMessageLegacyEncoder() {
+  return getStructEncoder(getPreludeStructEncoderTuple());
 }
-function toSerializer(codec) {
-  return {
-    description: codec.description,
-    deserialize: codec.decode,
-    fixedSize: codec.fixedSize,
-    maxSize: codec.maxSize,
-    serialize: codec.encode
-  };
+function getCompiledMessageVersionedEncoder() {
+  return mapEncoder(
+    getStructEncoder([
+      ...getPreludeStructEncoderTuple(),
+      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
+    ]),
+    (value) => {
+      if (value.version === "legacy") {
+        return value;
+      }
+      return {
+        ...value,
+        addressTableLookups: value.addressTableLookups ?? []
+      };
+    }
+  );
 }
-function getPreludeStructSerializerTuple() {
+function getPreludeStructEncoderTuple() {
   return [
-    ["version", toSerializer(getTransactionVersionCodec())],
-    ["header", toSerializer(getMessageHeaderCodec())],
+    ["version", getTransactionVersionEncoder()],
+    ["header", getMessageHeaderEncoder()],
     [
       "staticAccounts",
-      array(toSerializer(getAddressCodec()), {
-        description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
-        size: shortU16()
+      getArrayEncoder(getAddressEncoder(), {
+        description: staticAccountsDescription,
+        size: getShortU16Encoder()
       })
     ],
     [
       "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,
+      getStringEncoder({
+        description: lifetimeTokenDescription,
+        encoding: getBase58Encoder(),
         size: 32
       })
     ],
     [
       "instructions",
-      array(toSerializer(getInstructionCodec()), {
-        description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
-        size: shortU16()
+      getArrayEncoder(getInstructionEncoder(), {
+        description: instructionsDescription,
+        size: getShortU16Encoder()
       })
     ]
   ];
 }
-function getAddressTableLookupsSerializer() {
-  return array(toSerializer(getAddressTableLookupCodec()), {
-    ...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
-    size: shortU16()
+function getPreludeStructDecoderTuple() {
+  return [
+    ["version", getTransactionVersionDecoder()],
+    ["header", getMessageHeaderDecoder()],
+    [
+      "staticAccounts",
+      getArrayDecoder(getAddressDecoder(), {
+        description: staticAccountsDescription,
+        size: getShortU16Decoder()
+      })
+    ],
+    [
+      "lifetimeToken",
+      getStringDecoder({
+        description: lifetimeTokenDescription,
+        encoding: getBase58Decoder(),
+        size: 32
+      })
+    ],
+    [
+      "instructions",
+      getArrayDecoder(getInstructionDecoder(), {
+        description: instructionsDescription,
+        size: getShortU16Decoder()
+      })
+    ],
+    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
+  ];
+}
+function getAddressTableLookupArrayEncoder() {
+  return getArrayEncoder(getAddressTableLookupEncoder(), {
+    description: addressTableLookupsDescription,
+    size: getShortU16Encoder()
   });
 }
+function getAddressTableLookupArrayDecoder() {
+  return getArrayDecoder(getAddressTableLookupDecoder(), {
+    description: addressTableLookupsDescription,
+    size: getShortU16Decoder()
+  });
+}
+var messageDescription = __DEV__ ? "The wire format of a Solana transaction message" : "message";
 function getCompiledMessageEncoder() {
   return {
-    ...BASE_CONFIG2,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize
+    description: messageDescription,
+    encode: (compiledMessage) => {
+      if (compiledMessage.version === "legacy") {
+        return getCompiledMessageLegacyEncoder().encode(compiledMessage);
+      } else {
+        return getCompiledMessageVersionedEncoder().encode(compiledMessage);
+      }
+    },
+    fixedSize: null,
+    maxSize: null
   };
 }
+function getCompiledMessageDecoder() {
+  return mapDecoder(
+    getStructDecoder(getPreludeStructDecoderTuple(), {
+      description: messageDescription
+    }),
+    ({ addressTableLookups, ...restOfMessage }) => {
+      if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+        return restOfMessage;
+      }
+      return { ...restOfMessage, addressTableLookups };
+    }
+  );
+}
 
 // src/serializers/transaction.ts
-var BASE_CONFIG3 = {
-  description: __DEV__ ? "The wire format of a Solana transaction" : "",
-  fixedSize: null,
-  maxSize: null
-};
-function serialize2(transaction) {
-  const compiledTransaction = getCompiledTransaction(transaction);
-  return struct([
+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",
-      array(bytes({ size: 64 }), {
-        ...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
-        size: shortU16()
-      })
+      [
+        "signatures",
+        getArrayEncoder(getBytesEncoder({ size: 64 }), {
+          description: signaturesDescription,
+          size: getShortU16Encoder()
+        })
+      ],
+      ["compiledMessage", getCompiledMessageEncoder()]
     ],
-    ["compiledMessage", getCompiledMessageEncoder()]
-  ]).serialize(compiledTransaction);
+    {
+      description: transactionDescription
+    }
+  );
+}
+function getSignatureDecoder() {
+  return mapDecoder(getBytesDecoder({ size: 64 }), (bytes) => bytes);
+}
+function getCompiledTransactionDecoder() {
+  return getStructDecoder(
+    [
+      [
+        "signatures",
+        getArrayDecoder(getSignatureDecoder(), {
+          description: signaturesDescription,
+          size: getShortU16Decoder()
+        })
+      ],
+      ["compiledMessage", getCompiledMessageDecoder()]
+    ],
+    {
+      description: transactionDescription
+    }
+  );
 }
 function getTransactionEncoder() {
-  return {
-    ...BASE_CONFIG3,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize: serialize2
-  };
+  return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
+}
+function getTransactionDecoder(lastValidBlockHeight) {
+  return mapDecoder(
+    getCompiledTransactionDecoder(),
+    (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
+  );
+}
+function getTransactionCodec(lastValidBlockHeight) {
+  return combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
 }
 function assertIsTransactionSignature(putativeTransactionSignature) {
   try {
@@ -785,8 +988,8 @@ function assertIsTransactionSignature(putativeTransactionSignature) {
     ) {
       throw new Error("Expected input string to decode to a byte array of length 64.");
     }
-    const bytes2 = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes2.byteLength;
+    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}`);
     }
@@ -804,18 +1007,13 @@ function isTransactionSignature(putativeTransactionSignature) {
   ) {
     return false;
   }
-  const bytes2 = base58.serialize(putativeTransactionSignature);
-  const numBytes = bytes2.byteLength;
+  const bytes = base58.serialize(putativeTransactionSignature);
+  const numBytes = bytes.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 signatureBytes = transaction.signatures[transaction.feePayer];
   if (!signatureBytes) {
@@ -829,12 +1027,10 @@ function getSignatureFromTransaction(transaction) {
 async function signTransaction(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),
-        getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-      ])
+      (keyPair) => Promise.all([getAddressFromPublicKey(keyPair.publicKey), signBytes(keyPair.privateKey, wireMessageBytes)])
     )
   );
   for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
@@ -851,13 +1047,24 @@ function transactionSignature(putativeTransactionSignature) {
   assertIsTransactionSignature(putativeTransactionSignature);
   return putativeTransactionSignature;
 }
+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]);
+  requiredSigners.forEach((address) => {
+    if (!transaction.signatures[address]) {
+      throw new Error(`Transaction is missing signature for address \`${address}\``);
+    }
+  });
+}
 
 // src/wire-transaction.ts
 function getBase64EncodedWireTransaction(transaction) {
-  const wireTransactionBytes = getTransactionEncoder().serialize(transaction);
+  const wireTransactionBytes = getTransactionEncoder().encode(transaction);
   {
     return btoa(String.fromCharCode(...wireTransactionBytes));
   }
 }
 
-export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionEncoder, isAdvanceNonceAccountInstruction, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };
+export { appendTransactionInstruction, assertIsBlockhash, assertIsDurableNonceTransaction, assertIsTransactionSignature, assertTransactionIsFullySigned, createTransaction, getBase64EncodedWireTransaction, getSignatureFromTransaction, getTransactionCodec, getTransactionDecoder, getTransactionEncoder, isAdvanceNonceAccountInstruction, isTransactionSignature, prependTransactionInstruction, setTransactionFeePayer, setTransactionLifetimeUsingBlockhash, setTransactionLifetimeUsingDurableNonce, signTransaction, transactionSignature };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.native.js.map