@solana/transactions 2.0.0-experimental.0de6c3e → 2.0.0-experimental.0eb69ae

package/dist/index.browser.cjs

@@ -1,79 +1,74 @@
 'use strict';
 
+var codecsStrings = require('@solana/codecs-strings');
+var addresses = require('@solana/addresses');
+var codecsCore = require('@solana/codecs-core');
+var codecsDataStructures = require('@solana/codecs-data-structures');
+var codecsNumbers = require('@solana/codecs-numbers');
+var functional = require('@solana/functional');
 var keys = require('@solana/keys');
-var umiSerializers = require('@metaplex-foundation/umi-serializers');
 
 // ../build-scripts/env-shim.ts
 var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
 
-// src/create-transaction.ts
-function createTransaction({
-  version
-}) {
-  const out = {
-    instructions: [],
-    version
-  };
-  Object.freeze(out);
-  return out;
-}
-
-// src/fee-payer.ts
-function setTransactionFeePayer(feePayer, transaction) {
-  if ("feePayer" in transaction && feePayer === transaction.feePayer) {
-    return transaction;
-  }
-  let out;
+// src/unsigned-transaction.ts
+function getUnsignedTransaction(transaction) {
   if ("signatures" in transaction) {
     const {
       signatures: _,
       // eslint-disable-line @typescript-eslint/no-unused-vars
       ...unsignedTransaction
     } = transaction;
-    out = {
-      ...unsignedTransaction,
-      feePayer
-    };
+    return unsignedTransaction;
   } else {
-    out = {
-      ...transaction,
-      feePayer
-    };
+    return transaction;
   }
-  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
-    };
+// src/blockhash.ts
+var base58Encoder;
+function assertIsBlockhash(putativeBlockhash) {
+  if (!base58Encoder)
+    base58Encoder = codecsStrings.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
+    });
   }
-  return out;
 }
-function appendTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [...transaction.instructions, instruction];
-  const out = replaceInstructions(transaction, nextInstructions);
+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;
 }
-function prependTransactionInstruction(instruction, transaction) {
-  const nextInstructions = [instruction, ...transaction.instructions];
-  const out = replaceInstructions(transaction, nextInstructions);
+
+// src/create-transaction.ts
+function createTransaction({
+  version
+}) {
+  const out = {
+    instructions: [],
+    version
+  };
   Object.freeze(out);
   return out;
 }
@@ -100,6 +95,113 @@ function isWritableRole(role) {
 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;
+  }
+  const out = {
+    ...getUnsignedTransaction(transaction),
+    feePayer
+  };
+  Object.freeze(out);
+  return out;
+}
+
+// src/instructions.ts
+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;
+}
 function upsert(addressMap, address, update) {
   addressMap[address] = update(addressMap[address] ?? { role: AccountRole.READONLY });
 }
@@ -152,7 +254,7 @@ function getAddressMapFromInstructions(feePayer, instructions) {
                 const shouldReplaceEntry = (
                   // Consider using the new LOOKUP_TABLE if its address is different...
                   entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
-                  (addressComparator || (addressComparator = keys.getBase58EncodedAddressComparator()))(
+                  (addressComparator ||= addresses.getAddressComparator())(
                     accountMeta.lookupTableAddress,
                     entry.lookupTableAddress
                   ) < 0
@@ -258,7 +360,7 @@ function getOrderedAccountsFromAddressMap(addressMap) {
     if (leftIsWritable !== isWritableRole(rightEntry.role)) {
       return leftIsWritable ? -1 : 1;
     }
-    addressComparator || (addressComparator = keys.getBase58EncodedAddressComparator());
+    addressComparator ||= addresses.getAddressComparator();
     if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
       return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
     } else {
@@ -271,23 +373,22 @@ function getOrderedAccountsFromAddressMap(addressMap) {
   return orderedAccounts;
 }
 function getCompiledAddressTableLookups(orderedAccounts) {
-  var _a;
   const index = {};
   for (const account of orderedAccounts) {
     if (!("lookupTableAddress" in account)) {
       continue;
     }
-    const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
+    const entry = index[account.lookupTableAddress] ||= {
       readableIndices: [],
       writableIndices: []
-    });
+    };
     if (account.role === AccountRole.WRITABLE) {
       entry.writableIndices.push(account.addressIndex);
     } else {
       entry.readableIndices.push(account.addressIndex);
     }
   }
-  return Object.keys(index).sort(keys.getBase58EncodedAddressComparator()).map((lookupTableAddress) => ({
+  return Object.keys(index).sort(addresses.getAddressComparator()).map((lookupTableAddress) => ({
     lookupTableAddress,
     ...index[lookupTableAddress]
   }));
@@ -366,151 +467,189 @@ function compileMessage(transaction) {
     version: transaction.version
   };
 }
-function getAddressTableLookupCodec() {
-  return umiSerializers.struct(
-    [
+var lookupTableAddressDescription = __DEV__ ? "The address of the address lookup table account from which instruction addresses should be looked up" : "lookupTableAddress";
+var writableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as writeable" : "writableIndices";
+var readableIndicesDescription = __DEV__ ? "The indices of the accounts in the lookup table that should be loaded as read-only" : "readableIndices";
+var addressTableLookupDescription = __DEV__ ? "A pointer to the address of an address lookup table, along with the readonly/writeable indices of the addresses that should be loaded from it" : "addressTableLookup";
+var memoizedAddressTableLookupEncoder;
+function getAddressTableLookupEncoder() {
+  if (!memoizedAddressTableLookupEncoder) {
+    memoizedAddressTableLookupEncoder = codecsDataStructures.getStructEncoder(
       [
-        "lookupTableAddress",
-        keys.getBase58EncodedAddressCodec(
-          __DEV__ ? {
-            description: "The address of the address lookup table account from which instruction addresses should be looked up"
-          } : void 0
-        )
+        ["lookupTableAddress", addresses.getAddressEncoder({ description: lookupTableAddressDescription })],
+        [
+          "writableIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
+            description: writableIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ],
+        [
+          "readableIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder(), {
+            description: readableIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ]
       ],
+      { description: addressTableLookupDescription }
+    );
+  }
+  return memoizedAddressTableLookupEncoder;
+}
+var memoizedAddressTableLookupDecoder;
+function getAddressTableLookupDecoder() {
+  if (!memoizedAddressTableLookupDecoder) {
+    memoizedAddressTableLookupDecoder = codecsDataStructures.getStructDecoder(
       [
-        "writableIndices",
-        umiSerializers.array(umiSerializers.u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as writeable"
-          } : null,
-          size: umiSerializers.shortU16()
-        })
+        ["lookupTableAddress", addresses.getAddressDecoder({ description: lookupTableAddressDescription })],
+        [
+          "writableIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
+            description: writableIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ],
+        [
+          "readableIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder(), {
+            description: readableIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ]
       ],
-      [
-        "readableIndices",
-        umiSerializers.array(umiSerializers.u8(), {
-          ...__DEV__ ? {
-            description: "The indices of the accounts in the lookup table that should be loaded as read-only"
-          } : void 0,
-          size: umiSerializers.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
-  );
+      { description: addressTableLookupDescription }
+    );
+  }
+  return memoizedAddressTableLookupDecoder;
+}
+var memoizedU8Encoder;
+function getMemoizedU8Encoder() {
+  if (!memoizedU8Encoder)
+    memoizedU8Encoder = codecsNumbers.getU8Encoder();
+  return memoizedU8Encoder;
+}
+function getMemoizedU8EncoderDescription(description) {
+  const encoder = getMemoizedU8Encoder();
+  return {
+    ...encoder,
+    description: description ?? encoder.description
+  };
+}
+var memoizedU8Decoder;
+function getMemoizedU8Decoder() {
+  if (!memoizedU8Decoder)
+    memoizedU8Decoder = codecsNumbers.getU8Decoder();
+  return memoizedU8Decoder;
+}
+function getMemoizedU8DecoderDescription(description) {
+  const decoder = getMemoizedU8Decoder();
+  return {
+    ...decoder,
+    description: description ?? decoder.description
+  };
 }
-function getMessageHeaderCodec() {
-  return umiSerializers.struct(
+var numSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" : void 0;
+var numReadonlySignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction, but may not be writable" : void 0;
+var numReadonlyNonSignerAccountsDescription = __DEV__ ? "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable" : void 0;
+var messageHeaderDescription = __DEV__ ? "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses" : void 0;
+function getMessageHeaderEncoder() {
+  return codecsDataStructures.getStructEncoder(
     [
-      [
-        "numSignerAccounts",
-        umiSerializers.u8(
-          __DEV__ ? {
-            description: "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction"
-          } : void 0
-        )
-      ],
-      [
-        "numReadonlySignerAccounts",
-        umiSerializers.u8(
-          __DEV__ ? {
-            description: "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
-        )
-      ],
-      [
-        "numReadonlyNonSignerAccounts",
-        umiSerializers.u8(
-          __DEV__ ? {
-            description: "The expected number of addresses in the static address list belonging to accounts that are neither signers, nor writable"
-          } : void 0
-        )
-      ]
+      ["numSignerAccounts", getMemoizedU8EncoderDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8EncoderDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8EncoderDescription(numReadonlyNonSignerAccountsDescription)]
     ],
-    __DEV__ ? {
-      description: "The transaction message header containing counts of the signer, readonly-signer, and readonly-nonsigner account addresses"
-    } : void 0
+    {
+      description: messageHeaderDescription
+    }
   );
 }
-function getInstructionCodec() {
-  return umiSerializers.mapSerializer(
-    umiSerializers.struct([
-      [
-        "programAddressIndex",
-        umiSerializers.u8(
-          __DEV__ ? {
-            description: "The index of the program being called, according to the well-ordered accounts list for this transaction"
-          } : void 0
-        )
-      ],
-      [
-        "addressIndices",
-        umiSerializers.array(
-          umiSerializers.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: umiSerializers.shortU16()
-          }
-        )
-      ],
-      [
-        "data",
-        umiSerializers.bytes({
-          description: __DEV__ ? "An optional buffer of data passed to the instruction" : "",
-          size: umiSerializers.shortU16()
-        })
-      ]
-    ]),
-    (value) => {
-      if (value.addressIndices !== void 0 && value.data !== void 0) {
-        return value;
-      }
-      return {
-        ...value,
-        addressIndices: value.addressIndices ?? [],
-        data: value.data ?? new Uint8Array(0)
-      };
-    },
-    (value) => {
-      if (value.addressIndices.length && value.data.byteLength) {
-        return value;
-      }
-      const { addressIndices, data, ...rest } = value;
-      return {
-        ...rest,
-        ...addressIndices.length ? { addressIndices } : null,
-        ...data.byteLength ? { data } : null
-      };
+function getMessageHeaderDecoder() {
+  return codecsDataStructures.getStructDecoder(
+    [
+      ["numSignerAccounts", getMemoizedU8DecoderDescription(numSignerAccountsDescription)],
+      ["numReadonlySignerAccounts", getMemoizedU8DecoderDescription(numReadonlySignerAccountsDescription)],
+      ["numReadonlyNonSignerAccounts", getMemoizedU8DecoderDescription(numReadonlyNonSignerAccountsDescription)]
+    ],
+    {
+      description: messageHeaderDescription
     }
   );
 }
-
-// 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}`
-  );
+var programAddressIndexDescription = __DEV__ ? "The index of the program being called, according to the well-ordered accounts list for this transaction" : "programAddressIndex";
+var accountIndexDescription = __DEV__ ? "The index of an account, according to the well-ordered accounts list for this transaction" : void 0;
+var accountIndicesDescription = __DEV__ ? "An optional list of account indices, according to the well-ordered accounts list for this transaction, in the order in which the program being called expects them" : "accountIndices";
+var dataDescription = __DEV__ ? "An optional buffer of data passed to the instruction" : "data";
+var memoizedGetInstructionEncoder;
+function getInstructionEncoder() {
+  if (!memoizedGetInstructionEncoder) {
+    memoizedGetInstructionEncoder = codecsCore.mapEncoder(
+      codecsDataStructures.getStructEncoder([
+        ["programAddressIndex", codecsNumbers.getU8Encoder({ description: programAddressIndexDescription })],
+        [
+          "accountIndices",
+          codecsDataStructures.getArrayEncoder(codecsNumbers.getU8Encoder({ description: accountIndexDescription }), {
+            description: accountIndicesDescription,
+            size: codecsNumbers.getShortU16Encoder()
+          })
+        ],
+        ["data", codecsDataStructures.getBytesEncoder({ description: dataDescription, size: codecsNumbers.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;
 }
-function getUnimplementedDecoder(name) {
-  return () => {
-    throw getError("decoder", name);
-  };
+var memoizedGetInstructionDecoder;
+function getInstructionDecoder() {
+  if (!memoizedGetInstructionDecoder) {
+    memoizedGetInstructionDecoder = codecsCore.mapDecoder(
+      codecsDataStructures.getStructDecoder([
+        ["programAddressIndex", codecsNumbers.getU8Decoder({ description: programAddressIndexDescription })],
+        [
+          "accountIndices",
+          codecsDataStructures.getArrayDecoder(codecsNumbers.getU8Decoder({ description: accountIndexDescription }), {
+            description: accountIndicesDescription,
+            size: codecsNumbers.getShortU16Decoder()
+          })
+        ],
+        ["data", codecsDataStructures.getBytesDecoder({ description: dataDescription, size: codecsNumbers.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;
 }
-
-// src/serializers/transaction-version.ts
 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 deserialize(bytes3, offset = 0) {
-  const firstByte = bytes3[offset];
+function decode(bytes, offset = 0) {
+  const firstByte = bytes[offset];
   if ((firstByte & VERSION_FLAG_MASK) === 0) {
     return ["legacy", offset];
   } else {
@@ -518,7 +657,7 @@ function deserialize(bytes3, offset = 0) {
     return [version, offset + 1];
   }
 }
-function serialize(value) {
+function encode(value) {
   if (value === "legacy") {
     return new Uint8Array();
   }
@@ -527,105 +666,143 @@ function serialize(value) {
   }
   return new Uint8Array([value | VERSION_FLAG_MASK]);
 }
-function getTransactionVersionCodec() {
+function getTransactionVersionDecoder() {
   return {
     ...BASE_CONFIG,
-    deserialize,
-    serialize
+    decode
+  };
+}
+function getTransactionVersionEncoder() {
+  return {
+    ...BASE_CONFIG,
+    encode
   };
 }
 
 // src/serializers/message.ts
-var BASE_CONFIG2 = {
-  description: __DEV__ ? "The wire format of a Solana transaction message" : "",
-  fixedSize: null,
-  maxSize: null
-};
-function serialize2(compiledMessage) {
-  if (compiledMessage.version === "legacy") {
-    return umiSerializers.struct(getPreludeStructSerializerTuple()).serialize(compiledMessage);
-  } else {
-    return umiSerializers.mapSerializer(
-      umiSerializers.struct([
-        ...getPreludeStructSerializerTuple(),
-        ["addressTableLookups", getAddressTableLookupsSerializer()]
-      ]),
-      (value) => {
-        if (value.version === "legacy") {
-          return value;
-        }
-        return {
-          ...value,
-          addressTableLookups: value.addressTableLookups ?? []
-        };
+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 codecsDataStructures.getStructEncoder(getPreludeStructEncoderTuple());
+}
+function getCompiledMessageVersionedEncoder() {
+  return codecsCore.mapEncoder(
+    codecsDataStructures.getStructEncoder([
+      ...getPreludeStructEncoderTuple(),
+      ["addressTableLookups", getAddressTableLookupArrayEncoder()]
+    ]),
+    (value) => {
+      if (value.version === "legacy") {
+        return value;
       }
-    ).serialize(compiledMessage);
-  }
+      return {
+        ...value,
+        addressTableLookups: value.addressTableLookups ?? []
+      };
+    }
+  );
 }
-function getPreludeStructSerializerTuple() {
+function getPreludeStructEncoderTuple() {
   return [
-    ["version", getTransactionVersionCodec()],
-    ["header", getMessageHeaderCodec()],
+    ["version", getTransactionVersionEncoder()],
+    ["header", getMessageHeaderEncoder()],
     [
       "staticAccounts",
-      umiSerializers.array(keys.getBase58EncodedAddressCodec(), {
-        description: __DEV__ ? "A compact-array of static account addresses belonging to this transaction" : "",
-        size: umiSerializers.shortU16()
+      codecsDataStructures.getArrayEncoder(addresses.getAddressEncoder(), {
+        description: staticAccountsDescription,
+        size: codecsNumbers.getShortU16Encoder()
       })
     ],
     [
       "lifetimeToken",
-      umiSerializers.string({
-        description: __DEV__ ? "A 32-byte token that specifies the lifetime of this transaction (eg. a recent blockhash, or a durable nonce)" : "",
-        encoding: umiSerializers.base58,
+      codecsStrings.getStringEncoder({
+        description: lifetimeTokenDescription,
+        encoding: codecsStrings.getBase58Encoder(),
         size: 32
       })
     ],
     [
       "instructions",
-      umiSerializers.array(getInstructionCodec(), {
-        description: __DEV__ ? "A compact-array of instructions belonging to this transaction" : "",
-        size: umiSerializers.shortU16()
+      codecsDataStructures.getArrayEncoder(getInstructionEncoder(), {
+        description: instructionsDescription,
+        size: codecsNumbers.getShortU16Encoder()
       })
     ]
   ];
 }
-function getAddressTableLookupsSerializer() {
-  return umiSerializers.array(getAddressTableLookupCodec(), {
-    ...__DEV__ ? { description: "A compact array of address table lookups belonging to this transaction" } : null,
-    size: umiSerializers.shortU16()
+function getPreludeStructDecoderTuple() {
+  return [
+    ["version", getTransactionVersionDecoder()],
+    ["header", getMessageHeaderDecoder()],
+    [
+      "staticAccounts",
+      codecsDataStructures.getArrayDecoder(addresses.getAddressDecoder(), {
+        description: staticAccountsDescription,
+        size: codecsNumbers.getShortU16Decoder()
+      })
+    ],
+    [
+      "lifetimeToken",
+      codecsStrings.getStringDecoder({
+        description: lifetimeTokenDescription,
+        encoding: codecsStrings.getBase58Decoder(),
+        size: 32
+      })
+    ],
+    [
+      "instructions",
+      codecsDataStructures.getArrayDecoder(getInstructionDecoder(), {
+        description: instructionsDescription,
+        size: codecsNumbers.getShortU16Decoder()
+      })
+    ],
+    ["addressTableLookups", getAddressTableLookupArrayDecoder()]
+  ];
+}
+function getAddressTableLookupArrayEncoder() {
+  return codecsDataStructures.getArrayEncoder(getAddressTableLookupEncoder(), {
+    description: addressTableLookupsDescription,
+    size: codecsNumbers.getShortU16Encoder()
   });
 }
+function getAddressTableLookupArrayDecoder() {
+  return codecsDataStructures.getArrayDecoder(getAddressTableLookupDecoder(), {
+    description: addressTableLookupsDescription,
+    size: codecsNumbers.getShortU16Decoder()
+  });
+}
+var messageDescription = __DEV__ ? "The wire format of a Solana transaction message" : "message";
 function getCompiledMessageEncoder() {
   return {
-    ...BASE_CONFIG2,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize: serialize2
+    description: messageDescription,
+    encode: (compiledMessage) => {
+      if (compiledMessage.version === "legacy") {
+        return getCompiledMessageLegacyEncoder().encode(compiledMessage);
+      } else {
+        return getCompiledMessageVersionedEncoder().encode(compiledMessage);
+      }
+    },
+    fixedSize: null,
+    maxSize: null
   };
 }
-
-// src/signatures.ts
-async function getCompiledMessageSignature(message, secretKey) {
-  const wireMessageBytes = getCompiledMessageEncoder().serialize(message);
-  const signature = await keys.signBytes(secretKey, wireMessageBytes);
-  return signature;
+function getCompiledMessageDecoder() {
+  return codecsCore.mapDecoder(
+    codecsDataStructures.getStructDecoder(getPreludeStructDecoderTuple(), {
+      description: messageDescription
+    }),
+    ({ addressTableLookups, ...restOfMessage }) => {
+      if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+        return restOfMessage;
+      }
+      return { ...restOfMessage, addressTableLookups };
+    }
+  );
 }
-async function signTransaction(keyPair, transaction) {
-  const compiledMessage = compileMessage(transaction);
-  const [signerPublicKey, signature] = await Promise.all([
-    keys.getBase58EncodedAddressFromPublicKey(keyPair.publicKey),
-    getCompiledMessageSignature(compiledMessage, keyPair.privateKey)
-  ]);
-  const nextSignatures = {
-    ..."signatures" in transaction ? transaction.signatures : null,
-    ...{ [signerPublicKey]: signature }
-  };
-  const out = {
-    ...transaction,
-    signatures: nextSignatures
-  };
-  Object.freeze(out);
-  return out;
+function getCompiledMessageCodec() {
+  return codecsCore.combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
 }
 
 // src/compile-transaction.ts
@@ -645,47 +822,239 @@ 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;
+    addresses.assertIsAddress(nonceAccountAddress);
+    const nonceAuthorityAddress = firstInstruction.accounts[2].address;
+    addresses.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 functional.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
+  );
+}
 
 // src/serializers/transaction.ts
-var BASE_CONFIG3 = {
-  description: __DEV__ ? "The wire format of a Solana transaction" : "",
-  fixedSize: null,
-  maxSize: null
-};
-function serialize3(transaction) {
-  const compiledTransaction = getCompiledTransaction(transaction);
-  return umiSerializers.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 codecsDataStructures.getStructEncoder(
     [
-      "signatures",
-      umiSerializers.array(umiSerializers.bytes({ size: 64 }), {
-        ...__DEV__ ? { description: "A compact array of 64-byte, base-64 encoded Ed25519 signatures" } : null,
-        size: umiSerializers.shortU16()
-      })
+      [
+        "signatures",
+        codecsDataStructures.getArrayEncoder(codecsDataStructures.getBytesEncoder({ size: 64 }), {
+          description: signaturesDescription,
+          size: codecsNumbers.getShortU16Encoder()
+        })
+      ],
+      ["compiledMessage", getCompiledMessageEncoder()]
+    ],
+    {
+      description: transactionDescription
+    }
+  );
+}
+function getSignatureDecoder() {
+  return codecsCore.mapDecoder(codecsDataStructures.getBytesDecoder({ size: 64 }), (bytes) => bytes);
+}
+function getCompiledTransactionDecoder() {
+  return codecsDataStructures.getStructDecoder(
+    [
+      [
+        "signatures",
+        codecsDataStructures.getArrayDecoder(getSignatureDecoder(), {
+          description: signaturesDescription,
+          size: codecsNumbers.getShortU16Decoder()
+        })
+      ],
+      ["compiledMessage", getCompiledMessageDecoder()]
     ],
-    ["compiledMessage", getCompiledMessageEncoder()]
-  ]).serialize(compiledTransaction);
+    {
+      description: transactionDescription
+    }
+  );
 }
 function getTransactionEncoder() {
-  return {
-    ...BASE_CONFIG3,
-    deserialize: getUnimplementedDecoder("CompiledMessage"),
-    serialize: serialize3
+  return codecsCore.mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
+}
+function getTransactionDecoder(lastValidBlockHeight) {
+  return codecsCore.mapDecoder(
+    getCompiledTransactionDecoder(),
+    (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
+  );
+}
+function getTransactionCodec(lastValidBlockHeight) {
+  return codecsCore.combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
+}
+var base58Decoder;
+function getSignatureFromTransaction(transaction) {
+  if (!base58Decoder)
+    base58Decoder = codecsStrings.getBase58Decoder();
+  const signatureBytes = transaction.signatures[transaction.feePayer];
+  if (!signatureBytes) {
+    throw new Error(
+      "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
+    );
+  }
+  const transactionSignature = base58Decoder.decode(signatureBytes)[0];
+  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([addresses.getAddressFromPublicKey(keyPair.publicKey), keys.signBytes(keyPair.privateKey, wireMessageBytes)])
+    )
+  );
+  for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
+    nextSignatures[signerPublicKey] = signature;
+  }
+  const out = {
+    ...transaction,
+    signatures: nextSignatures
   };
+  Object.freeze(out);
+  return out;
+}
+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]);
+  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);
-  {
-    return btoa(String.fromCharCode(...wireTransactionBytes));
-  }
+  const wireTransactionBytes = getTransactionEncoder().encode(transaction);
+  return codecsStrings.getBase64Decoder().decode(wireTransactionBytes)[0];
 }
 
 exports.appendTransactionInstruction = appendTransactionInstruction;
+exports.assertIsBlockhash = assertIsBlockhash;
+exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
+exports.assertTransactionIsFullySigned = assertTransactionIsFullySigned;
+exports.compileMessage = compileMessage;
 exports.createTransaction = createTransaction;
 exports.getBase64EncodedWireTransaction = getBase64EncodedWireTransaction;
+exports.getCompiledMessageCodec = getCompiledMessageCodec;
+exports.getCompiledMessageDecoder = getCompiledMessageDecoder;
+exports.getCompiledMessageEncoder = getCompiledMessageEncoder;
+exports.getSignatureFromTransaction = getSignatureFromTransaction;
+exports.getTransactionCodec = getTransactionCodec;
+exports.getTransactionDecoder = getTransactionDecoder;
+exports.getTransactionEncoder = getTransactionEncoder;
+exports.isAdvanceNonceAccountInstruction = isAdvanceNonceAccountInstruction;
+exports.partiallySignTransaction = partiallySignTransaction;
 exports.prependTransactionInstruction = prependTransactionInstruction;
 exports.setTransactionFeePayer = setTransactionFeePayer;
+exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
+exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
 exports.signTransaction = signTransaction;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.browser.cjs.map