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

package/dist/index.development.js

@@ -2,269 +2,6 @@ this.globalThis = this.globalThis || {};
 this.globalThis.solanaWeb3 = (function (exports) {
   'use strict';
 
-  var __defProp = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
-  var InvalidBaseStringError = class extends Error {
-    constructor(value, base, cause) {
-      const message = `Expected a string of base ${base}, got [${value}].`;
-      super(message);
-      __publicField(this, "name", "InvalidBaseStringError");
-      this.cause = cause;
-    }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
-  var baseX = (alphabet) => {
-    const base = alphabet.length;
-    const baseBigInt = BigInt(base);
-    return {
-      description: `base${base}`,
-      fixedSize: null,
-      maxSize: null,
-      serialize(value) {
-        if (!value.match(new RegExp(`^[${alphabet}]*$`))) {
-          throw new InvalidBaseStringError(value, base);
-        }
-        if (value === "")
-          return new Uint8Array();
-        const chars = [...value];
-        let trailIndex = chars.findIndex((c) => c !== alphabet[0]);
-        trailIndex = trailIndex === -1 ? chars.length : trailIndex;
-        const leadingZeroes = Array(trailIndex).fill(0);
-        if (trailIndex === chars.length)
-          return Uint8Array.from(leadingZeroes);
-        const tailChars = chars.slice(trailIndex);
-        let base10Number = 0n;
-        let baseXPower = 1n;
-        for (let i = tailChars.length - 1; i >= 0; i -= 1) {
-          base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));
-          baseXPower *= baseBigInt;
-        }
-        const tailBytes = [];
-        while (base10Number > 0n) {
-          tailBytes.unshift(Number(base10Number % 256n));
-          base10Number /= 256n;
-        }
-        return Uint8Array.from(leadingZeroes.concat(tailBytes));
-      },
-      deserialize(buffer, offset = 0) {
-        if (buffer.length === 0)
-          return ["", 0];
-        const bytes = buffer.slice(offset);
-        let trailIndex = bytes.findIndex((n) => n !== 0);
-        trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
-        const leadingZeroes = alphabet[0].repeat(trailIndex);
-        if (trailIndex === bytes.length)
-          return [leadingZeroes, buffer.length];
-        let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
-        const tailChars = [];
-        while (base10Number > 0n) {
-          tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);
-          base10Number /= baseBigInt;
-        }
-        return [leadingZeroes + tailChars.join(""), buffer.length];
-      }
-    };
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.9/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
-  var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-
-  // 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 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}`);
-      }
-    } catch (e2) {
-      throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
-        cause: e2
-      });
-    }
-  }
-  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
-  }) {
-    const out = {
-      instructions: [],
-      version
-    };
-    Object.freeze(out);
-    return out;
-  }
-
-  // ../instructions/dist/index.browser.js
-  var AccountRole = /* @__PURE__ */ ((AccountRole2) => {
-    AccountRole2[AccountRole2["WRITABLE_SIGNER"] = /* 3 */
-    3] = "WRITABLE_SIGNER";
-    AccountRole2[AccountRole2["READONLY_SIGNER"] = /* 2 */
-    2] = "READONLY_SIGNER";
-    AccountRole2[AccountRole2["WRITABLE"] = /* 1 */
-    1] = "WRITABLE";
-    AccountRole2[AccountRole2["READONLY"] = /* 0 */
-    0] = "READONLY";
-    return AccountRole2;
-  })(AccountRole || {});
-  var IS_WRITABLE_BITMASK = 1;
-  function isSignerRole(role) {
-    return role >= 2;
-  }
-  function isWritableRole(role) {
-    return (role & IS_WRITABLE_BITMASK) !== 0;
-  }
-  function mergeRoles(roleA, roleB) {
-    return roleA | roleB;
-  }
-
-  // src/durable-nonce.ts
-  var RECENT_BLOCKHASHES_SYSVAR_ADDRESS = "SysvarRecentB1ockHashes11111111111111111111";
-  var SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
-  function assertIsDurableNonceTransaction(transaction) {
-    if (!isDurableNonceTransaction(transaction)) {
-      throw new Error("Transaction is not a durable nonce transaction");
-    }
-  }
-  function createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress) {
-    return {
-      accounts: [
-        { address: nonceAccountAddress, role: AccountRole.WRITABLE },
-        {
-          address: RECENT_BLOCKHASHES_SYSVAR_ADDRESS,
-          role: AccountRole.READONLY
-        },
-        { address: nonceAuthorityAddress, role: AccountRole.READONLY_SIGNER }
-      ],
-      data: new Uint8Array([4, 0, 0, 0]),
-      programAddress: SYSTEM_PROGRAM_ADDRESS
-    };
-  }
-  function isAdvanceNonceAccountInstruction(instruction) {
-    return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
-    instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
-    instruction.accounts?.length === 3 && // First account is nonce account address
-    instruction.accounts[0].address != null && instruction.accounts[0].role === AccountRole.WRITABLE && // Second account is recent blockhashes sysvar
-    instruction.accounts[1].address === RECENT_BLOCKHASHES_SYSVAR_ADDRESS && instruction.accounts[1].role === AccountRole.READONLY && // Third account is nonce authority account
-    instruction.accounts[2].address != null && isSignerRole(instruction.accounts[2].role);
-  }
-  function isAdvanceNonceAccountInstructionData(data) {
-    return data.byteLength === 4 && data[0] === 4 && data[1] === 0 && data[2] === 0 && data[3] === 0;
-  }
-  function isDurableNonceTransaction(transaction) {
-    return "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.nonce === "string" && transaction.instructions[0] != null && isAdvanceNonceAccountInstruction(transaction.instructions[0]);
-  }
-  function isAdvanceNonceAccountInstructionForNonce(instruction, nonceAccountAddress, nonceAuthorityAddress) {
-    return instruction.accounts[0].address === nonceAccountAddress && instruction.accounts[2].address === nonceAuthorityAddress;
-  }
-  function setTransactionLifetimeUsingDurableNonce({
-    nonce,
-    nonceAccountAddress,
-    nonceAuthorityAddress
-  }, transaction) {
-    let newInstructions;
-    const firstInstruction = transaction.instructions[0];
-    if (firstInstruction && isAdvanceNonceAccountInstruction(firstInstruction)) {
-      if (isAdvanceNonceAccountInstructionForNonce(firstInstruction, nonceAccountAddress, nonceAuthorityAddress)) {
-        if (isDurableNonceTransaction(transaction) && transaction.lifetimeConstraint.nonce === nonce) {
-          return transaction;
-        } else {
-          newInstructions = [firstInstruction, ...transaction.instructions.slice(1)];
-        }
-      } else {
-        newInstructions = [
-          createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
-          ...transaction.instructions.slice(1)
-        ];
-      }
-    } else {
-      newInstructions = [
-        createAdvanceNonceAccountInstruction(nonceAccountAddress, nonceAuthorityAddress),
-        ...transaction.instructions
-      ];
-    }
-    const out = {
-      ...getUnsignedTransaction(transaction),
-      instructions: newInstructions,
-      lifetimeConstraint: {
-        nonce
-      }
-    };
-    Object.freeze(out);
-    return out;
-  }
-
-  // src/fee-payer.ts
-  function setTransactionFeePayer(feePayer, transaction) {
-    if ("feePayer" in transaction && feePayer === transaction.feePayer) {
-      return transaction;
-    }
-    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;
-  }
-
   // ../codecs-core/dist/index.browser.js
   function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
     if (bytes.length - offset <= 0) {
@@ -320,7 +57,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
     return {
       decode: decoder.decode,
-      description: description ?? encoder.description,
+      description: description != null ? description : encoder.description,
       encode: encoder.encode,
       fixedSize: encoder.fixedSize,
       maxSize: encoder.maxSize
@@ -328,7 +65,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
   function fixCodecHelper(data, fixedBytes, description) {
     return {
-      description: description ?? `fixed(${fixedBytes}, ${data.description})`,
+      description: description != null ? description : `fixed(${fixedBytes}, ${data.description})`,
       fixedSize: fixedBytes,
       maxSize: fixedBytes
     };
@@ -384,14 +121,15 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
   function sharedNumberFactory(input) {
+    var _a;
     let littleEndian;
     let defaultDescription = input.name;
     if (input.size > 1) {
-      littleEndian = !("endian" in input.options) || input.options.endian === 0;
+      littleEndian = !("endian" in input.config) || input.config.endian === 0;
       defaultDescription += littleEndian ? "(le)" : "(be)";
     }
     return {
-      description: input.options.description ?? defaultDescription,
+      description: (_a = input.config.description) != null ? _a : defaultDescription,
       fixedSize: input.size,
       littleEndian,
       maxSize: input.size
@@ -428,255 +166,83 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
   function toArrayBuffer(bytes, offset, length) {
-    const bytesOffset = bytes.byteOffset + (offset ?? 0);
-    const bytesLength = length ?? bytes.byteLength;
+    const bytesOffset = bytes.byteOffset + (offset != null ? offset : 0);
+    const bytesLength = length != null ? length : bytes.byteLength;
     return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
   }
-  var getShortU16Encoder = (options = {}) => ({
-    description: options.description ?? "shortU16",
-    encode: (value) => {
-      assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
-      const bytes = [0];
-      for (let ii = 0; ; ii += 1) {
-        const alignedValue = value >> ii * 7;
-        if (alignedValue === 0) {
-          break;
-        }
-        const nextSevenBits = 127 & alignedValue;
-        bytes[ii] = nextSevenBits;
-        if (ii > 0) {
-          bytes[ii - 1] |= 128;
+  var getShortU16Encoder = (config = {}) => {
+    var _a;
+    return {
+      description: (_a = config.description) != null ? _a : "shortU16",
+      encode: (value) => {
+        assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
+        const bytes = [0];
+        for (let ii = 0; ; ii += 1) {
+          const alignedValue = value >> ii * 7;
+          if (alignedValue === 0) {
+            break;
+          }
+          const nextSevenBits = 127 & alignedValue;
+          bytes[ii] = nextSevenBits;
+          if (ii > 0) {
+            bytes[ii - 1] |= 128;
+          }
         }
-      }
-      return new Uint8Array(bytes);
-    },
-    fixedSize: null,
-    maxSize: 3
-  });
-  var getShortU16Decoder = (options = {}) => ({
-    decode: (bytes, offset = 0) => {
-      let value = 0;
-      let byteCount = 0;
-      while (++byteCount) {
-        const byteIndex = byteCount - 1;
-        const currentByte = bytes[offset + byteIndex];
-        const nextSevenBits = 127 & currentByte;
-        value |= nextSevenBits << byteIndex * 7;
-        if ((currentByte & 128) === 0) {
-          break;
+        return new Uint8Array(bytes);
+      },
+      fixedSize: null,
+      maxSize: 3
+    };
+  };
+  var getShortU16Decoder = (config = {}) => {
+    var _a;
+    return {
+      decode: (bytes, offset = 0) => {
+        let value = 0;
+        let byteCount = 0;
+        while (++byteCount) {
+          const byteIndex = byteCount - 1;
+          const currentByte = bytes[offset + byteIndex];
+          const nextSevenBits = 127 & currentByte;
+          value |= nextSevenBits << byteIndex * 7;
+          if ((currentByte & 128) === 0) {
+            break;
+          }
         }
-      }
-      return [value, offset + byteCount];
-    },
-    description: options.description ?? "shortU16",
-    fixedSize: null,
-    maxSize: 3
-  });
-  var getU32Encoder = (options = {}) => numberEncoderFactory({
+        return [value, offset + byteCount];
+      },
+      description: (_a = config.description) != null ? _a : "shortU16",
+      fixedSize: null,
+      maxSize: 3
+    };
+  };
+  var getU32Encoder = (config = {}) => numberEncoderFactory({
+    config,
     name: "u32",
-    options,
     range: [0, Number("0xffffffff")],
     set: (view, value, le) => view.setUint32(0, value, le),
     size: 4
   });
-  var getU32Decoder = (options = {}) => numberDecoderFactory({
+  var getU32Decoder = (config = {}) => numberDecoderFactory({
+    config,
     get: (view, le) => view.getUint32(0, le),
     name: "u32",
-    options,
     size: 4
   });
-  var getU8Encoder = (options = {}) => numberEncoderFactory({
+  var getU8Encoder = (config = {}) => numberEncoderFactory({
+    config,
     name: "u8",
-    options,
     range: [0, Number("0xff")],
     set: (view, value) => view.setUint8(0, value),
     size: 1
   });
-  var getU8Decoder = (options = {}) => numberDecoderFactory({
+  var getU8Decoder = (config = {}) => numberDecoderFactory({
+    config,
     get: (view) => view.getUint8(0),
     name: "u8",
-    options,
     size: 1
   });
 
-  // ../codecs-data-structures/dist/index.browser.js
-  function sumCodecSizes(sizes) {
-    return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
-  }
-  function decodeArrayLikeCodecSize(size, childrenSizes, bytes, offset) {
-    if (typeof size === "number") {
-      return [size, offset];
-    }
-    if (typeof size === "object") {
-      return size.decode(bytes, offset);
-    }
-    if (size === "remainder") {
-      const childrenSize = sumCodecSizes(childrenSizes);
-      if (childrenSize === null) {
-        throw new Error('Codecs of "remainder" size must have fixed-size items.');
-      }
-      const remainder = bytes.slice(offset).length;
-      if (remainder % childrenSize !== 0) {
-        throw new Error(
-          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${childrenSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${childrenSize} should be equal to zero.`
-        );
-      }
-      return [remainder / childrenSize, offset];
-    }
-    throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
-  }
-  function getArrayLikeCodecSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${size}`;
-  }
-  function getArrayLikeCodecSizeFromChildren(size, childrenSizes) {
-    if (typeof size !== "number")
-      return null;
-    if (size === 0)
-      return 0;
-    const childrenSize = sumCodecSizes(childrenSizes);
-    return childrenSize === null ? null : childrenSize * size;
-  }
-  function getArrayLikeCodecSizePrefix(size, realSize) {
-    return typeof size === "object" ? size.encode(realSize) : new Uint8Array();
-  }
-  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
-    if (expected !== actual) {
-      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
-    }
-  }
-  function arrayCodecHelper(item, size, description) {
-    if (size === "remainder" && item.fixedSize === null) {
-      throw new Error('Codecs of "remainder" size must have fixed-size items.');
-    }
-    return {
-      description: description ?? `array(${item.description}; ${getArrayLikeCodecSizeDescription(size)})`,
-      fixedSize: getArrayLikeCodecSizeFromChildren(size, [item.fixedSize]),
-      maxSize: getArrayLikeCodecSizeFromChildren(size, [item.maxSize])
-    };
-  }
-  function getArrayEncoder(item, options = {}) {
-    const size = options.size ?? getU32Encoder();
-    return {
-      ...arrayCodecHelper(item, size, options.description),
-      encode: (value) => {
-        if (typeof size === "number") {
-          assertValidNumberOfItemsForCodec("array", size, value.length);
-        }
-        return mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
-      }
-    };
-  }
-  function getArrayDecoder(item, options = {}) {
-    const size = options.size ?? getU32Decoder();
-    return {
-      ...arrayCodecHelper(item, size, options.description),
-      decode: (bytes, offset = 0) => {
-        if (typeof size === "object" && bytes.slice(offset).length === 0) {
-          return [[], offset];
-        }
-        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes, offset);
-        offset = newOffset;
-        const values = [];
-        for (let i = 0; i < resolvedSize; i += 1) {
-          const [value, newOffset2] = item.decode(bytes, offset);
-          values.push(value);
-          offset = newOffset2;
-        }
-        return [values, offset];
-      }
-    };
-  }
-  function getBytesEncoder(options = {}) {
-    const size = options.size ?? "variable";
-    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-    const description = options.description ?? `bytes(${sizeDescription})`;
-    const byteEncoder = {
-      description,
-      encode: (value) => value,
-      fixedSize: null,
-      maxSize: null
-    };
-    if (size === "variable") {
-      return byteEncoder;
-    }
-    if (typeof size === "number") {
-      return fixEncoder(byteEncoder, size, description);
-    }
-    return {
-      ...byteEncoder,
-      encode: (value) => {
-        const contentBytes = byteEncoder.encode(value);
-        const lengthBytes = size.encode(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
-      }
-    };
-  }
-  function getBytesDecoder(options = {}) {
-    const size = options.size ?? "variable";
-    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
-    const description = options.description ?? `bytes(${sizeDescription})`;
-    const byteDecoder = {
-      decode: (bytes, offset = 0) => {
-        const slice = bytes.slice(offset);
-        return [slice, offset + slice.length];
-      },
-      description,
-      fixedSize: null,
-      maxSize: null
-    };
-    if (size === "variable") {
-      return byteDecoder;
-    }
-    if (typeof size === "number") {
-      return fixDecoder(byteDecoder, size, description);
-    }
-    return {
-      ...byteDecoder,
-      decode: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("bytes", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBytes = bytes.slice(offset, offset + length);
-        assertByteArrayHasEnoughBytesForCodec("bytes", length, contentBytes);
-        const [value, contentOffset] = byteDecoder.decode(contentBytes);
-        offset += contentOffset;
-        return [value, offset];
-      }
-    };
-  }
-  function structCodecHelper(fields, description) {
-    const fieldDescriptions = fields.map(([name, codec]) => `${String(name)}: ${codec.description}`).join(", ");
-    return {
-      description: description ?? `struct(${fieldDescriptions})`,
-      fixedSize: sumCodecSizes(fields.map(([, field]) => field.fixedSize)),
-      maxSize: sumCodecSizes(fields.map(([, field]) => field.maxSize))
-    };
-  }
-  function getStructEncoder(fields, options = {}) {
-    return {
-      ...structCodecHelper(fields, options.description),
-      encode: (struct) => {
-        const fieldBytes = fields.map(([key, codec]) => codec.encode(struct[key]));
-        return mergeBytes(fieldBytes);
-      }
-    };
-  }
-  function getStructDecoder(fields, options = {}) {
-    return {
-      ...structCodecHelper(fields, options.description),
-      decode: (bytes, offset = 0) => {
-        const struct = {};
-        fields.forEach(([key, codec]) => {
-          const [value, newOffset] = codec.decode(bytes, offset);
-          offset = newOffset;
-          struct[key] = value;
-        });
-        return [struct, offset];
-      }
-    };
-  }
-
   // ../codecs-strings/dist/index.browser.js
   function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
     if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
@@ -745,6 +311,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
   var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
   var getBase58Encoder = () => getBaseXEncoder(alphabet2);
   var getBase58Decoder = () => getBaseXDecoder(alphabet2);
+  var getBase64Decoder = () => {
+    {
+      return {
+        decode(bytes, offset = 0) {
+          const slice = bytes.slice(offset);
+          const value = btoa(String.fromCharCode(...slice));
+          return [value, bytes.length];
+        },
+        description: `base64`,
+        fixedSize: null,
+        maxSize: null
+      };
+    }
+  };
   var removeNullCharacters = (value) => (
     // eslint-disable-next-line no-control-regex
     value.replace(/\u0000/g, "")
@@ -772,56 +352,251 @@ this.globalThis.solanaWeb3 = (function (exports) {
       maxSize: null
     };
   };
-  var getStringEncoder = (options = {}) => {
-    const size = options.size ?? getU32Encoder();
-    const encoding = options.encoding ?? getUtf8Encoder();
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
+  var getStringEncoder = (config = {}) => {
+    var _a, _b, _c;
+    const size = (_a = config.size) != null ? _a : getU32Encoder();
+    const encoding = (_b = config.encoding) != null ? _b : getUtf8Encoder();
+    const description = (_c = config.description) != null ? _c : `string(${encoding.description}; ${getSizeDescription(size)})`;
     if (size === "variable") {
       return { ...encoding, description };
     }
     if (typeof size === "number") {
       return fixEncoder(encoding, size, description);
     }
-    return {
-      description,
-      encode: (value) => {
-        const contentBytes = encoding.encode(value);
-        const lengthBytes = size.encode(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
-      },
-      fixedSize: null,
-      maxSize: null
+    return {
+      description,
+      encode: (value) => {
+        const contentBytes = encoding.encode(value);
+        const lengthBytes = size.encode(contentBytes.length);
+        return mergeBytes([lengthBytes, contentBytes]);
+      },
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  var getStringDecoder = (config = {}) => {
+    var _a, _b, _c;
+    const size = (_a = config.size) != null ? _a : getU32Decoder();
+    const encoding = (_b = config.encoding) != null ? _b : getUtf8Decoder();
+    const description = (_c = config.description) != null ? _c : `string(${encoding.description}; ${getSizeDescription(size)})`;
+    if (size === "variable") {
+      return { ...encoding, description };
+    }
+    if (typeof size === "number") {
+      return fixDecoder(encoding, size, description);
+    }
+    return {
+      decode: (bytes, offset = 0) => {
+        assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
+        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
+        const length = Number(lengthBigInt);
+        offset = lengthOffset;
+        const contentBytes = bytes.slice(offset, offset + length);
+        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
+        const [value, contentOffset] = encoding.decode(contentBytes);
+        offset += contentOffset;
+        return [value, offset];
+      },
+      description,
+      fixedSize: null,
+      maxSize: null
+    };
+  };
+  function getSizeDescription(size) {
+    return typeof size === "object" ? size.description : `${size}`;
+  }
+
+  // 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
+  var base58Encoder;
+  function assertIsBlockhash(putativeBlockhash) {
+    if (!base58Encoder)
+      base58Encoder = getBase58Encoder();
+    try {
+      if (
+        // Lowest value (32 bytes of zeroes)
+        putativeBlockhash.length < 32 || // Highest value (32 bytes of 255)
+        putativeBlockhash.length > 44
+      ) {
+        throw new Error("Expected input string to decode to a byte array of length 32.");
+      }
+      const bytes = base58Encoder.encode(putativeBlockhash);
+      const numBytes = bytes.byteLength;
+      if (numBytes !== 32) {
+        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
+      }
+    } catch (e2) {
+      throw new Error(`\`${putativeBlockhash}\` is not a blockhash`, {
+        cause: e2
+      });
+    }
+  }
+  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
+  }) {
+    const out = {
+      instructions: [],
+      version
+    };
+    Object.freeze(out);
+    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) {
+    var _a;
+    return instruction.programAddress === SYSTEM_PROGRAM_ADDRESS && // Test for `AdvanceNonceAccount` instruction data
+    instruction.data != null && isAdvanceNonceAccountInstructionData(instruction.data) && // Test for exactly 3 accounts
+    ((_a = instruction.accounts) == null ? void 0 : _a.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
+      }
     };
-  };
-  var getStringDecoder = (options = {}) => {
-    const size = options.size ?? getU32Decoder();
-    const encoding = options.encoding ?? getUtf8Decoder();
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
-    if (size === "variable") {
-      return { ...encoding, description };
-    }
-    if (typeof size === "number") {
-      return fixDecoder(encoding, size, description);
+    Object.freeze(out);
+    return out;
+  }
+
+  // src/fee-payer.ts
+  function setTransactionFeePayer(feePayer, transaction) {
+    if ("feePayer" in transaction && feePayer === transaction.feePayer) {
+      return transaction;
     }
-    return {
-      decode: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBytes = bytes.slice(offset, offset + length);
-        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
-        const [value, contentOffset] = encoding.decode(contentBytes);
-        offset += contentOffset;
-        return [value, offset];
-      },
-      description,
-      fixedSize: null,
-      maxSize: null
+    const out = {
+      ...getUnsignedTransaction(transaction),
+      feePayer
     };
-  };
-  function getSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${size}`;
+    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;
   }
 
   // ../assertions/dist/index.browser.js
@@ -833,14 +608,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
   async function assertKeyExporterIsAvailable() {
+    var _a;
     assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") {
+    if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.exportKey) !== "function") {
       throw new Error("No key export implementation could be found");
     }
   }
   async function assertSigningCapabilityIsAvailable() {
+    var _a;
     assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.sign !== "function") {
+    if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.sign) !== "function") {
       throw new Error("No signing implementation could be found");
     }
   }
@@ -858,35 +635,36 @@ this.globalThis.solanaWeb3 = (function (exports) {
       memoizedBase58Decoder = getBase58Decoder();
     return memoizedBase58Decoder;
   }
-  function assertIsAddress(putativeBase58EncodedAddress) {
+  function assertIsAddress(putativeAddress) {
     try {
       if (
         // Lowest address (32 bytes of zeroes)
-        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-        putativeBase58EncodedAddress.length > 44
+        putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+        putativeAddress.length > 44
       ) {
         throw new Error("Expected input string to decode to a byte array of length 32.");
       }
-      const base58Encoder = getMemoizedBase58Encoder();
-      const bytes = base58Encoder.encode(putativeBase58EncodedAddress);
+      const base58Encoder2 = getMemoizedBase58Encoder();
+      const bytes = base58Encoder2.encode(putativeAddress);
       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 (e2) {
-      throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
+      throw new Error(`\`${putativeAddress}\` is not a base-58 encoded address`, {
         cause: e2
       });
     }
   }
-  function address(putativeBase58EncodedAddress) {
-    assertIsAddress(putativeBase58EncodedAddress);
-    return putativeBase58EncodedAddress;
+  function address(putativeAddress) {
+    assertIsAddress(putativeAddress);
+    return putativeAddress;
   }
   function getAddressEncoder(config) {
+    var _a;
     return mapEncoder(
       getStringEncoder({
-        description: config?.description ?? "Base58EncodedAddress",
+        description: (_a = config == null ? void 0 : config.description) != null ? _a : "Address",
         encoding: getMemoizedBase58Encoder(),
         size: 32
       }),
@@ -894,8 +672,9 @@ this.globalThis.solanaWeb3 = (function (exports) {
     );
   }
   function getAddressDecoder(config) {
+    var _a;
     return getStringDecoder({
-      description: config?.description ?? "Base58EncodedAddress",
+      description: (_a = config == null ? void 0 : config.description) != null ? _a : "Address",
       encoding: getMemoizedBase58Decoder(),
       size: 32
     });
@@ -922,7 +701,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
 
   // src/accounts.ts
   function upsert(addressMap, address2, update) {
-    addressMap[address2] = update(addressMap[address2] ?? { role: AccountRole.READONLY });
+    var _a;
+    addressMap[address2] = update((_a = addressMap[address2]) != null ? _a : { role: AccountRole.READONLY });
   }
   var TYPE = Symbol("AddressMapTypeProperty");
   function getAddressMapFromInstructions(feePayer, instructions) {
@@ -1190,139 +970,186 @@ this.globalThis.solanaWeb3 = (function (exports) {
     };
   }
 
-  // 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));
+  // ../codecs-data-structures/dist/index.browser.js
+  function sumCodecSizes(sizes) {
+    return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
+  }
+  function decodeArrayLikeCodecSize(size, childrenSizes, bytes, offset) {
+    if (typeof size === "number") {
+      return [size, offset];
+    }
+    if (typeof size === "object") {
+      return size.decode(bytes, offset);
+    }
+    if (size === "remainder") {
+      const childrenSize = sumCodecSizes(childrenSizes);
+      if (childrenSize === null) {
+        throw new Error('Codecs of "remainder" size must have fixed-size items.');
       }
-    } else {
-      signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
+      const remainder = bytes.slice(offset).length;
+      if (remainder % childrenSize !== 0) {
+        throw new Error(
+          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${childrenSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${childrenSize} should be equal to zero.`
+        );
+      }
+      return [remainder / childrenSize, offset];
+    }
+    throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
+  }
+  function getArrayLikeCodecSizeDescription(size) {
+    return typeof size === "object" ? size.description : `${size}`;
+  }
+  function getArrayLikeCodecSizeFromChildren(size, childrenSizes) {
+    if (typeof size !== "number")
+      return null;
+    if (size === 0)
+      return 0;
+    const childrenSize = sumCodecSizes(childrenSizes);
+    return childrenSize === null ? null : childrenSize * size;
+  }
+  function getArrayLikeCodecSizePrefix(size, realSize) {
+    return typeof size === "object" ? size.encode(realSize) : new Uint8Array();
+  }
+  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
+    if (expected !== actual) {
+      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
+    }
+  }
+  function arrayCodecHelper(item, size, description) {
+    if (size === "remainder" && item.fixedSize === null) {
+      throw new Error('Codecs of "remainder" size must have fixed-size items.');
     }
     return {
-      compiledMessage,
-      signatures
+      description: description != null ? description : `array(${item.description}; ${getArrayLikeCodecSizeDescription(size)})`,
+      fixedSize: getArrayLikeCodecSizeFromChildren(size, [item.fixedSize]),
+      maxSize: getArrayLikeCodecSizeFromChildren(size, [item.maxSize])
     };
   }
-
-  // ../functional/dist/index.browser.js
-  function pipe(init, ...fns) {
-    return fns.reduce((acc, fn) => fn(acc), init);
+  function getArrayEncoder(item, config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : getU32Encoder();
+    return {
+      ...arrayCodecHelper(item, size, config.description),
+      encode: (value) => {
+        if (typeof size === "number") {
+          assertValidNumberOfItemsForCodec("array", size, value.length);
+        }
+        return mergeBytes([getArrayLikeCodecSizePrefix(size, value.length), ...value.map((v) => item.encode(v))]);
+      }
+    };
   }
-
-  // src/decompile-transaction.ts
-  function getAccountMetas(message) {
-    const { header } = message;
-    const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
-    const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
-    const accountMetas = [];
-    let accountIndex = 0;
-    for (let i = 0; i < numWritableSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole.WRITABLE_SIGNER
-      });
-      accountIndex++;
-    }
-    for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole.READONLY_SIGNER
-      });
-      accountIndex++;
+  function getArrayDecoder(item, config = {}) {
+    var _a;
+    const size = (_a = config.size) != null ? _a : getU32Decoder();
+    return {
+      ...arrayCodecHelper(item, size, config.description),
+      decode: (bytes, offset = 0) => {
+        if (typeof size === "object" && bytes.slice(offset).length === 0) {
+          return [[], offset];
+        }
+        const [resolvedSize, newOffset] = decodeArrayLikeCodecSize(size, [item.fixedSize], bytes, offset);
+        offset = newOffset;
+        const values = [];
+        for (let i = 0; i < resolvedSize; i += 1) {
+          const [value, newOffset2] = item.decode(bytes, offset);
+          values.push(value);
+          offset = newOffset2;
+        }
+        return [values, offset];
+      }
+    };
+  }
+  function getBytesEncoder(config = {}) {
+    var _a, _b;
+    const size = (_a = config.size) != null ? _a : "variable";
+    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
+    const description = (_b = config.description) != null ? _b : `bytes(${sizeDescription})`;
+    const byteEncoder = {
+      description,
+      encode: (value) => value,
+      fixedSize: null,
+      maxSize: null
+    };
+    if (size === "variable") {
+      return byteEncoder;
     }
-    for (let i = 0; i < numWritableNonSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole.WRITABLE
-      });
-      accountIndex++;
+    if (typeof size === "number") {
+      return fixEncoder(byteEncoder, size, description);
     }
-    for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
-      accountMetas.push({
-        address: message.staticAccounts[accountIndex],
-        role: AccountRole.READONLY
-      });
-      accountIndex++;
+    return {
+      ...byteEncoder,
+      encode: (value) => {
+        const contentBytes = byteEncoder.encode(value);
+        const lengthBytes = size.encode(contentBytes.length);
+        return mergeBytes([lengthBytes, contentBytes]);
+      }
+    };
+  }
+  function getBytesDecoder(config = {}) {
+    var _a, _b;
+    const size = (_a = config.size) != null ? _a : "variable";
+    const sizeDescription = typeof size === "object" ? size.description : `${size}`;
+    const description = (_b = config.description) != null ? _b : `bytes(${sizeDescription})`;
+    const byteDecoder = {
+      decode: (bytes, offset = 0) => {
+        const slice = bytes.slice(offset);
+        return [slice, offset + slice.length];
+      },
+      description,
+      fixedSize: null,
+      maxSize: null
+    };
+    if (size === "variable") {
+      return byteDecoder;
     }
-    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}`);
+    if (typeof size === "number") {
+      return fixDecoder(byteDecoder, size, description);
     }
-    const accounts = instruction.accountIndices?.map((accountIndex) => accountMetas[accountIndex]);
-    const { data } = instruction;
     return {
-      programAddress,
-      ...accounts && accounts.length ? { accounts } : {},
-      ...data && data.length ? { data } : {}
+      ...byteDecoder,
+      decode: (bytes, offset = 0) => {
+        assertByteArrayIsNotEmptyForCodec("bytes", bytes, offset);
+        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
+        const length = Number(lengthBigInt);
+        offset = lengthOffset;
+        const contentBytes = bytes.slice(offset, offset + length);
+        assertByteArrayHasEnoughBytesForCodec("bytes", length, contentBytes);
+        const [value, contentOffset] = byteDecoder.decode(contentBytes);
+        offset += contentOffset;
+        return [value, offset];
+      }
     };
   }
-  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 structCodecHelper(fields, description) {
+    const fieldDescriptions = fields.map(([name, codec]) => `${String(name)}: ${codec.description}`).join(", ");
+    return {
+      description: description != null ? description : `struct(${fieldDescriptions})`,
+      fixedSize: sumCodecSizes(fields.map(([, field]) => field.fixedSize)),
+      maxSize: sumCodecSizes(fields.map(([, field]) => field.maxSize))
+    };
   }
-  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 address2 = staticAccounts[index];
-      return { ...acc, [address2]: sig };
-    }, {});
+  function getStructEncoder(fields, config = {}) {
+    return {
+      ...structCodecHelper(fields, config.description),
+      encode: (struct) => {
+        const fieldBytes = fields.map(([key, codec]) => codec.encode(struct[key]));
+        return mergeBytes(fieldBytes);
+      }
+    };
   }
-  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
-    );
+  function getStructDecoder(fields, config = {}) {
+    return {
+      ...structCodecHelper(fields, config.description),
+      decode: (bytes, offset = 0) => {
+        const struct = {};
+        fields.forEach(([key, codec]) => {
+          const [value, newOffset] = codec.decode(bytes, offset);
+          offset = newOffset;
+          struct[key] = value;
+        });
+        return [struct, offset];
+      }
+    };
   }
 
   // src/serializers/address-table-lookup.ts
@@ -1394,7 +1221,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const encoder = getMemoizedU8Encoder();
     return {
       ...encoder,
-      description: description ?? encoder.description
+      description: description != null ? description : encoder.description
     };
   }
   var memoizedU8Decoder;
@@ -1407,7 +1234,7 @@ this.globalThis.solanaWeb3 = (function (exports) {
     const decoder = getMemoizedU8Decoder();
     return {
       ...decoder,
-      description: description ?? decoder.description
+      description: description != null ? description : decoder.description
     };
   }
   var numSignerAccountsDescription = "The expected number of addresses in the static address list belonging to accounts that are required to sign this transaction" ;
@@ -1461,13 +1288,14 @@ this.globalThis.solanaWeb3 = (function (exports) {
         ]),
         // Convert an instruction to have all fields defined
         (instruction) => {
+          var _a, _b;
           if (instruction.accountIndices !== void 0 && instruction.data !== void 0) {
             return instruction;
           }
           return {
             ...instruction,
-            accountIndices: instruction.accountIndices ?? [],
-            data: instruction.data ?? new Uint8Array(0)
+            accountIndices: (_a = instruction.accountIndices) != null ? _a : [],
+            data: (_b = instruction.data) != null ? _b : new Uint8Array(0)
           };
         }
       );
@@ -1559,12 +1387,13 @@ this.globalThis.solanaWeb3 = (function (exports) {
         ["addressTableLookups", getAddressTableLookupArrayEncoder()]
       ]),
       (value) => {
+        var _a;
         if (value.version === "legacy") {
           return value;
         }
         return {
           ...value,
-          addressTableLookups: value.addressTableLookups ?? []
+          addressTableLookups: (_a = value.addressTableLookups) != null ? _a : []
         };
       }
     );
@@ -1659,13 +1488,153 @@ this.globalThis.solanaWeb3 = (function (exports) {
         description: messageDescription
       }),
       ({ addressTableLookups, ...restOfMessage }) => {
-        if (restOfMessage.version === "legacy" || !addressTableLookups?.length) {
+        if (restOfMessage.version === "legacy" || !(addressTableLookups == null ? void 0 : addressTableLookups.length)) {
           return restOfMessage;
         }
         return { ...restOfMessage, addressTableLookups };
       }
     );
   }
+  function getCompiledMessageCodec() {
+    return combineCodec(getCompiledMessageEncoder(), getCompiledMessageDecoder());
+  }
+
+  // src/compile-transaction.ts
+  function getCompiledTransaction(transaction) {
+    var _a;
+    const compiledMessage = compileMessage(transaction);
+    let signatures;
+    if ("signatures" in transaction) {
+      signatures = [];
+      for (let ii = 0; ii < compiledMessage.header.numSignerAccounts; ii++) {
+        signatures[ii] = (_a = transaction.signatures[compiledMessage.staticAccounts[ii]]) != null ? _a : new Uint8Array(Array(64).fill(0));
+      }
+    } else {
+      signatures = Array(compiledMessage.header.numSignerAccounts).fill(new Uint8Array(Array(64).fill(0)));
+    }
+    return {
+      compiledMessage,
+      signatures
+    };
+  }
+
+  // ../functional/dist/index.browser.js
+  function pipe(init, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), init);
+  }
+
+  // src/decompile-transaction.ts
+  function getAccountMetas(message) {
+    const { header } = message;
+    const numWritableSignerAccounts = header.numSignerAccounts - header.numReadonlySignerAccounts;
+    const numWritableNonSignerAccounts = message.staticAccounts.length - header.numSignerAccounts - header.numReadonlyNonSignerAccounts;
+    const accountMetas = [];
+    let accountIndex = 0;
+    for (let i = 0; i < numWritableSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole.WRITABLE_SIGNER
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < header.numReadonlySignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole.READONLY_SIGNER
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < numWritableNonSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole.WRITABLE
+      });
+      accountIndex++;
+    }
+    for (let i = 0; i < header.numReadonlyNonSignerAccounts; i++) {
+      accountMetas.push({
+        address: message.staticAccounts[accountIndex],
+        role: AccountRole.READONLY
+      });
+      accountIndex++;
+    }
+    return accountMetas;
+  }
+  function convertInstruction(instruction, accountMetas) {
+    var _a, _b;
+    const programAddress = (_a = accountMetas[instruction.programAddressIndex]) == null ? void 0 : _a.address;
+    if (!programAddress) {
+      throw new Error(`Could not find program address at index ${instruction.programAddressIndex}`);
+    }
+    const accounts = (_b = instruction.accountIndices) == null ? void 0 : _b.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 != null ? 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 address2 = staticAccounts[index];
+      return { ...acc, [address2]: 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
+    );
+  }
 
   // src/serializers/transaction.ts
   var signaturesDescription = "A compact array of 64-byte, base-64 encoded Ed25519 signatures" ;
@@ -1728,52 +1697,20 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
 
   // src/signatures.ts
-  function assertIsTransactionSignature(putativeTransactionSignature) {
-    try {
-      if (
-        // Lowest value (64 bytes of zeroes)
-        putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-        putativeTransactionSignature.length > 88
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 64.");
-      }
-      const bytes = base58.serialize(putativeTransactionSignature);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 64) {
-        throw new Error(`Expected input string to decode to a byte array of length 64. Actual length: ${numBytes}`);
-      }
-    } catch (e2) {
-      throw new Error(`\`${putativeTransactionSignature}\` is not a transaction signature`, {
-        cause: e2
-      });
-    }
-  }
-  function isTransactionSignature(putativeTransactionSignature) {
-    if (
-      // Lowest value (64 bytes of zeroes)
-      putativeTransactionSignature.length < 64 || // Highest value (64 bytes of 255)
-      putativeTransactionSignature.length > 88
-    ) {
-      return false;
-    }
-    const bytes = base58.serialize(putativeTransactionSignature);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 64) {
-      return false;
-    }
-    return true;
-  }
+  var base58Decoder;
   function getSignatureFromTransaction(transaction) {
+    if (!base58Decoder)
+      base58Decoder = getBase58Decoder();
     const signatureBytes = transaction.signatures[transaction.feePayer];
     if (!signatureBytes) {
       throw new Error(
         "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer."
       );
     }
-    const transactionSignature2 = base58.deserialize(signatureBytes)[0];
-    return transactionSignature2;
+    const transactionSignature = base58Decoder.decode(signatureBytes)[0];
+    return transactionSignature;
   }
-  async function signTransaction(keyPairs, transaction) {
+  async function partiallySignTransaction(keyPairs, transaction) {
     const compiledMessage = compileMessage(transaction);
     const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
     const wireMessageBytes = getCompiledMessageEncoder().encode(compiledMessage);
@@ -1792,12 +1729,17 @@ this.globalThis.solanaWeb3 = (function (exports) {
     Object.freeze(out);
     return out;
   }
-  function transactionSignature(putativeTransactionSignature) {
-    assertIsTransactionSignature(putativeTransactionSignature);
-    return putativeTransactionSignature;
+  async function signTransaction(keyPairs, transaction) {
+    const out = await partiallySignTransaction(keyPairs, transaction);
+    assertTransactionIsFullySigned(out);
+    Object.freeze(out);
+    return out;
   }
   function assertTransactionIsFullySigned(transaction) {
-    const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => i.accounts?.filter((a) => isSignerRole(a.role)) ?? []).map((a) => a.address);
+    const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => {
+      var _a, _b;
+      return (_b = (_a = i.accounts) == null ? void 0 : _a.filter((a) => isSignerRole(a.role))) != null ? _b : [];
+    }).map((a) => a.address);
     const requiredSigners = /* @__PURE__ */ new Set([transaction.feePayer, ...signerAddressesFromInstructions]);
     requiredSigners.forEach((address2) => {
       if (!transaction.signatures[address2]) {
@@ -1809,30 +1751,30 @@ this.globalThis.solanaWeb3 = (function (exports) {
   // src/wire-transaction.ts
   function getBase64EncodedWireTransaction(transaction) {
     const wireTransactionBytes = getTransactionEncoder().encode(transaction);
-    {
-      return btoa(String.fromCharCode(...wireTransactionBytes));
-    }
+    return getBase64Decoder().decode(wireTransactionBytes)[0];
   }
 
   exports.appendTransactionInstruction = appendTransactionInstruction;
   exports.assertIsBlockhash = assertIsBlockhash;
   exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
-  exports.assertIsTransactionSignature = assertIsTransactionSignature;
   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.isTransactionSignature = isTransactionSignature;
+  exports.partiallySignTransaction = partiallySignTransaction;
   exports.prependTransactionInstruction = prependTransactionInstruction;
   exports.setTransactionFeePayer = setTransactionFeePayer;
   exports.setTransactionLifetimeUsingBlockhash = setTransactionLifetimeUsingBlockhash;
   exports.setTransactionLifetimeUsingDurableNonce = setTransactionLifetimeUsingDurableNonce;
   exports.signTransaction = signTransaction;
-  exports.transactionSignature = transactionSignature;
 
   return exports;