@solana/transactions 2.0.0-experimental.e1ca396 → 2.0.0-experimental.e58bb22

package/dist/index.development.js

@@ -1,1628 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-  'use strict';
-
-  // ../codecs-core/dist/index.browser.js
-  function assertByteArrayIsNotEmptyForCodec(codecDescription, bytes, offset = 0) {
-    if (bytes.length - offset <= 0) {
-      throw new Error(`Codec [${codecDescription}] cannot decode empty byte arrays.`);
-    }
-  }
-  function assertByteArrayHasEnoughBytesForCodec(codecDescription, expected, bytes, offset = 0) {
-    const bytesLength = bytes.length - offset;
-    if (bytesLength < expected) {
-      throw new Error(`Codec [${codecDescription}] expected ${expected} bytes, got ${bytesLength}.`);
-    }
-  }
-  var padBytes = (bytes, length) => {
-    if (bytes.length >= length)
-      return bytes;
-    const paddedBytes = new Uint8Array(length).fill(0);
-    paddedBytes.set(bytes);
-    return paddedBytes;
-  };
-  var fixBytes = (bytes, length) => padBytes(bytes.length <= length ? bytes : bytes.slice(0, length), length);
-  function getEncodedSize(value, encoder) {
-    return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
-  }
-  function createEncoder(encoder) {
-    return Object.freeze({
-      ...encoder,
-      encode: (value) => {
-        const bytes = new Uint8Array(getEncodedSize(value, encoder));
-        encoder.write(value, bytes, 0);
-        return bytes;
-      }
-    });
-  }
-  function createDecoder(decoder) {
-    return Object.freeze({
-      ...decoder,
-      decode: (bytes, offset = 0) => decoder.read(bytes, offset)[0]
-    });
-  }
-  function isFixedSize(codec) {
-    return "fixedSize" in codec && typeof codec.fixedSize === "number";
-  }
-  function assertIsFixedSize(codec, message) {
-    if (!isFixedSize(codec)) {
-      throw new Error(message != null ? message : "Expected a fixed-size codec, got a variable-size one.");
-    }
-  }
-  function isVariableSize(codec) {
-    return !isFixedSize(codec);
-  }
-  function combineCodec(encoder, decoder) {
-    if (isFixedSize(encoder) !== isFixedSize(decoder)) {
-      throw new Error(`Encoder and decoder must either both be fixed-size or variable-size.`);
-    }
-    if (isFixedSize(encoder) && isFixedSize(decoder) && encoder.fixedSize !== decoder.fixedSize) {
-      throw new Error(
-        `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
-      );
-    }
-    if (!isFixedSize(encoder) && !isFixedSize(decoder) && encoder.maxSize !== decoder.maxSize) {
-      throw new Error(
-        `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
-      );
-    }
-    return {
-      ...decoder,
-      ...encoder,
-      decode: decoder.decode,
-      encode: encoder.encode,
-      read: decoder.read,
-      write: encoder.write
-    };
-  }
-  function fixEncoder(encoder, fixedBytes) {
-    return createEncoder({
-      fixedSize: fixedBytes,
-      write: (value, bytes, offset) => {
-        const variableByteArray = encoder.encode(value);
-        const fixedByteArray = variableByteArray.length > fixedBytes ? variableByteArray.slice(0, fixedBytes) : variableByteArray;
-        bytes.set(fixedByteArray, offset);
-        return offset + fixedBytes;
-      }
-    });
-  }
-  function fixDecoder(decoder, fixedBytes) {
-    return createDecoder({
-      fixedSize: fixedBytes,
-      read: (bytes, offset) => {
-        assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes, offset);
-        if (offset > 0 || bytes.length > fixedBytes) {
-          bytes = bytes.slice(offset, offset + fixedBytes);
-        }
-        if (isFixedSize(decoder)) {
-          bytes = fixBytes(bytes, decoder.fixedSize);
-        }
-        const [value] = decoder.read(bytes, 0);
-        return [value, offset + fixedBytes];
-      }
-    });
-  }
-  function mapEncoder(encoder, unmap) {
-    return createEncoder({
-      ...isVariableSize(encoder) ? { ...encoder, getSizeFromValue: (value) => encoder.getSizeFromValue(unmap(value)) } : encoder,
-      write: (value, bytes, offset) => encoder.write(unmap(value), bytes, offset)
-    });
-  }
-  function mapDecoder(decoder, map) {
-    return createDecoder({
-      ...decoder,
-      read: (bytes, offset) => {
-        const [value, newOffset] = decoder.read(bytes, offset);
-        return [map(value, bytes, offset), newOffset];
-      }
-    });
-  }
-
-  // ../codecs-numbers/dist/index.browser.js
-  function assertNumberIsBetweenForCodec(codecDescription, min, max, value) {
-    if (value < min || value > max) {
-      throw new Error(
-        `Codec [${codecDescription}] expected number to be in the range [${min}, ${max}], got ${value}.`
-      );
-    }
-  }
-  function isLittleEndian(config) {
-    return (config == null ? void 0 : config.endian) === 1 ? false : true;
-  }
-  function numberEncoderFactory(input) {
-    return createEncoder({
-      fixedSize: input.size,
-      write(value, bytes, offset) {
-        if (input.range) {
-          assertNumberIsBetweenForCodec(input.name, input.range[0], input.range[1], value);
-        }
-        const arrayBuffer = new ArrayBuffer(input.size);
-        input.set(new DataView(arrayBuffer), value, isLittleEndian(input.config));
-        bytes.set(new Uint8Array(arrayBuffer), offset);
-        return offset + input.size;
-      }
-    });
-  }
-  function numberDecoderFactory(input) {
-    return createDecoder({
-      fixedSize: input.size,
-      read(bytes, offset = 0) {
-        assertByteArrayIsNotEmptyForCodec(input.name, bytes, offset);
-        assertByteArrayHasEnoughBytesForCodec(input.name, input.size, bytes, offset);
-        const view = new DataView(toArrayBuffer(bytes, offset, input.size));
-        return [input.get(view, isLittleEndian(input.config)), offset + input.size];
-      }
-    });
-  }
-  function toArrayBuffer(bytes, offset, length) {
-    const bytesOffset = bytes.byteOffset + (offset != null ? offset : 0);
-    const bytesLength = length != null ? length : bytes.byteLength;
-    return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
-  }
-  var getShortU16Encoder = () => createEncoder({
-    getSizeFromValue: (value) => {
-      if (value <= 127)
-        return 1;
-      if (value <= 16383)
-        return 2;
-      return 3;
-    },
-    maxSize: 3,
-    write: (value, bytes, offset) => {
-      assertNumberIsBetweenForCodec("shortU16", 0, 65535, value);
-      const shortU16Bytes = [0];
-      for (let ii = 0; ; ii += 1) {
-        const alignedValue = value >> ii * 7;
-        if (alignedValue === 0) {
-          break;
-        }
-        const nextSevenBits = 127 & alignedValue;
-        shortU16Bytes[ii] = nextSevenBits;
-        if (ii > 0) {
-          shortU16Bytes[ii - 1] |= 128;
-        }
-      }
-      bytes.set(shortU16Bytes, offset);
-      return offset + shortU16Bytes.length;
-    }
-  });
-  var getShortU16Decoder = () => createDecoder({
-    maxSize: 3,
-    read: (bytes, offset) => {
-      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];
-    }
-  });
-  var getU32Encoder = (config = {}) => numberEncoderFactory({
-    config,
-    name: "u32",
-    range: [0, Number("0xffffffff")],
-    set: (view, value, le) => view.setUint32(0, value, le),
-    size: 4
-  });
-  var getU32Decoder = (config = {}) => numberDecoderFactory({
-    config,
-    get: (view, le) => view.getUint32(0, le),
-    name: "u32",
-    size: 4
-  });
-  var getU8Encoder = () => numberEncoderFactory({
-    name: "u8",
-    range: [0, Number("0xff")],
-    set: (view, value) => view.setUint8(0, value),
-    size: 1
-  });
-  var getU8Decoder = () => numberDecoderFactory({
-    get: (view) => view.getUint8(0),
-    name: "u8",
-    size: 1
-  });
-
-  // ../codecs-strings/dist/index.browser.js
-  function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
-    if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
-      throw new Error(`Expected a string of base ${alphabet4.length}, got [${givenValue}].`);
-    }
-  }
-  var getBaseXEncoder = (alphabet4) => {
-    return createEncoder({
-      getSizeFromValue: (value) => {
-        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
-        if (tailChars === "")
-          return value.length;
-        const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
-        return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
-      },
-      write(value, bytes, offset) {
-        assertValidBaseString(alphabet4, value);
-        if (value === "")
-          return offset;
-        const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
-        if (tailChars === "") {
-          bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
-          return offset + leadingZeroes.length;
-        }
-        let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
-        const tailBytes = [];
-        while (base10Number > 0n) {
-          tailBytes.unshift(Number(base10Number % 256n));
-          base10Number /= 256n;
-        }
-        const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
-        bytes.set(bytesToAdd, offset);
-        return offset + bytesToAdd.length;
-      }
-    });
-  };
-  var getBaseXDecoder = (alphabet4) => {
-    return createDecoder({
-      read(rawBytes, offset) {
-        const bytes = offset === 0 ? rawBytes : rawBytes.slice(offset);
-        if (bytes.length === 0)
-          return ["", 0];
-        let trailIndex = bytes.findIndex((n) => n !== 0);
-        trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
-        const leadingZeroes = alphabet4[0].repeat(trailIndex);
-        if (trailIndex === bytes.length)
-          return [leadingZeroes, rawBytes.length];
-        const base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
-        const tailChars = getBaseXFromBigInt(base10Number, alphabet4);
-        return [leadingZeroes + tailChars, rawBytes.length];
-      }
-    });
-  };
-  function partitionLeadingZeroes(value, zeroCharacter) {
-    const leadingZeroIndex = [...value].findIndex((c) => c !== zeroCharacter);
-    return leadingZeroIndex === -1 ? [value, ""] : [value.slice(0, leadingZeroIndex), value.slice(leadingZeroIndex)];
-  }
-  function getBigIntFromBaseX(value, alphabet4) {
-    const base = BigInt(alphabet4.length);
-    return [...value].reduce((sum, char) => sum * base + BigInt(alphabet4.indexOf(char)), 0n);
-  }
-  function getBaseXFromBigInt(value, alphabet4) {
-    const base = BigInt(alphabet4.length);
-    const tailChars = [];
-    while (value > 0n) {
-      tailChars.unshift(alphabet4[Number(value % base)]);
-      value /= base;
-    }
-    return tailChars.join("");
-  }
-  var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  var getBase58Encoder = () => getBaseXEncoder(alphabet2);
-  var getBase58Decoder = () => getBaseXDecoder(alphabet2);
-  var getBase64Decoder = () => {
-    {
-      return createDecoder({
-        read(bytes, offset = 0) {
-          const slice = bytes.slice(offset);
-          const value = btoa(String.fromCharCode(...slice));
-          return [value, bytes.length];
-        }
-      });
-    }
-  };
-  var removeNullCharacters = (value) => (
-    // eslint-disable-next-line no-control-regex
-    value.replace(/\u0000/g, "")
-  );
-  var e = globalThis.TextDecoder;
-  var o = globalThis.TextEncoder;
-  var getUtf8Encoder = () => {
-    let textEncoder;
-    return createEncoder({
-      getSizeFromValue: (value) => (textEncoder || (textEncoder = new o())).encode(value).length,
-      write: (value, bytes, offset) => {
-        const bytesToAdd = (textEncoder || (textEncoder = new o())).encode(value);
-        bytes.set(bytesToAdd, offset);
-        return offset + bytesToAdd.length;
-      }
-    });
-  };
-  var getUtf8Decoder = () => {
-    let textDecoder;
-    return createDecoder({
-      read(bytes, offset) {
-        const value = (textDecoder || (textDecoder = new e())).decode(bytes.slice(offset));
-        return [removeNullCharacters(value), bytes.length];
-      }
-    });
-  };
-  function getStringEncoder(config = {}) {
-    var _a, _b;
-    const size = (_a = config.size) != null ? _a : getU32Encoder();
-    const encoding = (_b = config.encoding) != null ? _b : getUtf8Encoder();
-    if (size === "variable") {
-      return encoding;
-    }
-    if (typeof size === "number") {
-      return fixEncoder(encoding, size);
-    }
-    return createEncoder({
-      getSizeFromValue: (value) => {
-        const contentSize = getEncodedSize(value, encoding);
-        return getEncodedSize(contentSize, size) + contentSize;
-      },
-      write: (value, bytes, offset) => {
-        const contentSize = getEncodedSize(value, encoding);
-        offset = size.write(contentSize, bytes, offset);
-        return encoding.write(value, bytes, offset);
-      }
-    });
-  }
-  function getStringDecoder(config = {}) {
-    var _a, _b;
-    const size = (_a = config.size) != null ? _a : getU32Decoder();
-    const encoding = (_b = config.encoding) != null ? _b : getUtf8Decoder();
-    if (size === "variable") {
-      return encoding;
-    }
-    if (typeof size === "number") {
-      return fixDecoder(encoding, size);
-    }
-    return createDecoder({
-      read: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.read(bytes, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBytes = bytes.slice(offset, offset + length);
-        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
-        const [value, contentOffset] = encoding.read(contentBytes, 0);
-        offset += contentOffset;
-        return [value, offset];
-      }
-    });
-  }
-
-  // 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 isTransactionWithBlockhashLifetime(transaction) {
-    const lifetimeConstraintShapeMatches = "lifetimeConstraint" in transaction && typeof transaction.lifetimeConstraint.blockhash === "string" && typeof transaction.lifetimeConstraint.lastValidBlockHeight === "bigint";
-    if (!lifetimeConstraintShapeMatches)
-      return false;
-    try {
-      assertIsBlockhash(transaction.lifetimeConstraint.blockhash);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  function assertIsTransactionWithBlockhashLifetime(transaction) {
-    if (!isTransactionWithBlockhashLifetime(transaction)) {
-      throw new Error("Transaction does not have a blockhash lifetime");
-    }
-  }
-  function setTransactionLifetimeUsingBlockhash(blockhashLifetimeConstraint, transaction) {
-    if ("lifetimeConstraint" in transaction && transaction.lifetimeConstraint.blockhash === blockhashLifetimeConstraint.blockhash && transaction.lifetimeConstraint.lastValidBlockHeight === blockhashLifetimeConstraint.lastValidBlockHeight) {
-      return transaction;
-    }
-    const out = {
-      ...getUnsignedTransaction(transaction),
-      lifetimeConstraint: blockhashLifetimeConstraint
-    };
-    Object.freeze(out);
-    return out;
-  }
-
-  // src/create-transaction.ts
-  function createTransaction({
-    version
-  }) {
-    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
-      }
-    };
-    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;
-  }
-
-  // ../assertions/dist/index.browser.js
-  function assertIsSecureContext() {
-    if (!globalThis.isSecureContext) {
-      throw new Error(
-        "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts"
-      );
-    }
-  }
-  async function assertKeyExporterIsAvailable() {
-    var _a;
-    assertIsSecureContext();
-    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 ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.sign) !== "function") {
-      throw new Error("No signing implementation could be found");
-    }
-  }
-
-  // ../addresses/dist/index.browser.js
-  var memoizedBase58Encoder;
-  var memoizedBase58Decoder;
-  function getMemoizedBase58Encoder() {
-    if (!memoizedBase58Encoder)
-      memoizedBase58Encoder = getBase58Encoder();
-    return memoizedBase58Encoder;
-  }
-  function getMemoizedBase58Decoder() {
-    if (!memoizedBase58Decoder)
-      memoizedBase58Decoder = getBase58Decoder();
-    return memoizedBase58Decoder;
-  }
-  function assertIsAddress(putativeAddress) {
-    try {
-      if (
-        // Lowest address (32 bytes of zeroes)
-        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 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(`\`${putativeAddress}\` is not a base-58 encoded address`, {
-        cause: e2
-      });
-    }
-  }
-  function address(putativeAddress) {
-    assertIsAddress(putativeAddress);
-    return putativeAddress;
-  }
-  function getAddressEncoder() {
-    return mapEncoder(
-      getStringEncoder({ encoding: getMemoizedBase58Encoder(), size: 32 }),
-      (putativeAddress) => address(putativeAddress)
-    );
-  }
-  function getAddressDecoder() {
-    return getStringDecoder({ encoding: getMemoizedBase58Decoder(), size: 32 });
-  }
-  function getAddressComparator() {
-    return new Intl.Collator("en", {
-      caseFirst: "lower",
-      ignorePunctuation: false,
-      localeMatcher: "best fit",
-      numeric: false,
-      sensitivity: "variant",
-      usage: "sort"
-    }).compare;
-  }
-  async function getAddressFromPublicKey(publicKey) {
-    await assertKeyExporterIsAvailable();
-    if (publicKey.type !== "public" || publicKey.algorithm.name !== "Ed25519") {
-      throw new Error("The `CryptoKey` must be an `Ed25519` public key");
-    }
-    const publicKeyBytes = await crypto.subtle.exportKey("raw", publicKey);
-    return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
-  }
-
-  // src/accounts.ts
-  function upsert(addressMap, address2, update) {
-    var _a;
-    addressMap[address2] = update((_a = addressMap[address2]) != null ? _a : { role: AccountRole.READONLY });
-  }
-  var TYPE = Symbol("AddressMapTypeProperty");
-  function getAddressMapFromInstructions(feePayer, instructions) {
-    const addressMap = {
-      [feePayer]: { [TYPE]: 0 /* FEE_PAYER */, role: AccountRole.WRITABLE_SIGNER }
-    };
-    const addressesOfInvokedPrograms = /* @__PURE__ */ new Set();
-    for (const instruction of instructions) {
-      upsert(addressMap, instruction.programAddress, (entry) => {
-        addressesOfInvokedPrograms.add(instruction.programAddress);
-        if (TYPE in entry) {
-          if (isWritableRole(entry.role)) {
-            switch (entry[TYPE]) {
-              case 0 /* FEE_PAYER */:
-                throw new Error(
-                  `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and set as the fee payer. Program addresses may not pay fees.`
-                );
-              default:
-                throw new Error(
-                  `This transaction includes an address (\`${instruction.programAddress}\`) which is both invoked and marked writable. Program addresses may not be writable.`
-                );
-            }
-          }
-          if (entry[TYPE] === 2 /* STATIC */) {
-            return entry;
-          }
-        }
-        return { [TYPE]: 2 /* STATIC */, role: AccountRole.READONLY };
-      });
-      let addressComparator;
-      if (!instruction.accounts) {
-        continue;
-      }
-      for (const account of instruction.accounts) {
-        upsert(addressMap, account.address, (entry) => {
-          const {
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            address: _,
-            ...accountMeta
-          } = account;
-          if (TYPE in entry) {
-            switch (entry[TYPE]) {
-              case 0 /* FEE_PAYER */:
-                return entry;
-              case 1 /* LOOKUP_TABLE */: {
-                const nextRole = mergeRoles(entry.role, accountMeta.role);
-                if ("lookupTableAddress" in accountMeta) {
-                  const shouldReplaceEntry = (
-                    // Consider using the new LOOKUP_TABLE if its address is different...
-                    entry.lookupTableAddress !== accountMeta.lookupTableAddress && // ...and sorts before the existing one.
-                    (addressComparator || (addressComparator = getAddressComparator()))(
-                      accountMeta.lookupTableAddress,
-                      entry.lookupTableAddress
-                    ) < 0
-                  );
-                  if (shouldReplaceEntry) {
-                    return {
-                      [TYPE]: 1 /* LOOKUP_TABLE */,
-                      ...accountMeta,
-                      role: nextRole
-                    };
-                  }
-                } else if (isSignerRole(accountMeta.role)) {
-                  return {
-                    [TYPE]: 2 /* STATIC */,
-                    role: nextRole
-                  };
-                }
-                if (entry.role !== nextRole) {
-                  return {
-                    ...entry,
-                    role: nextRole
-                  };
-                } else {
-                  return entry;
-                }
-              }
-              case 2 /* STATIC */: {
-                const nextRole = mergeRoles(entry.role, accountMeta.role);
-                if (
-                  // Check to see if this address represents a program that is invoked
-                  // in this transaction.
-                  addressesOfInvokedPrograms.has(account.address)
-                ) {
-                  if (isWritableRole(accountMeta.role)) {
-                    throw new Error(
-                      `This transaction includes an address (\`${account.address}\`) which is both invoked and marked writable. Program addresses may not be writable.`
-                    );
-                  }
-                  if (entry.role !== nextRole) {
-                    return {
-                      ...entry,
-                      role: nextRole
-                    };
-                  } else {
-                    return entry;
-                  }
-                } else if ("lookupTableAddress" in accountMeta && // Static accounts can be 'upgraded' to lookup table accounts as
-                // long as they are not require to sign the transaction.
-                !isSignerRole(entry.role)) {
-                  return {
-                    ...accountMeta,
-                    [TYPE]: 1 /* LOOKUP_TABLE */,
-                    role: nextRole
-                  };
-                } else {
-                  if (entry.role !== nextRole) {
-                    return {
-                      ...entry,
-                      role: nextRole
-                    };
-                  } else {
-                    return entry;
-                  }
-                }
-              }
-            }
-          }
-          if ("lookupTableAddress" in accountMeta) {
-            return {
-              ...accountMeta,
-              [TYPE]: 1 /* LOOKUP_TABLE */
-            };
-          } else {
-            return {
-              ...accountMeta,
-              [TYPE]: 2 /* STATIC */
-            };
-          }
-        });
-      }
-    }
-    return addressMap;
-  }
-  function getOrderedAccountsFromAddressMap(addressMap) {
-    let addressComparator;
-    const orderedAccounts = Object.entries(addressMap).sort(([leftAddress, leftEntry], [rightAddress, rightEntry]) => {
-      if (leftEntry[TYPE] !== rightEntry[TYPE]) {
-        if (leftEntry[TYPE] === 0 /* FEE_PAYER */) {
-          return -1;
-        } else if (rightEntry[TYPE] === 0 /* FEE_PAYER */) {
-          return 1;
-        } else if (leftEntry[TYPE] === 2 /* STATIC */) {
-          return -1;
-        } else if (rightEntry[TYPE] === 2 /* STATIC */) {
-          return 1;
-        }
-      }
-      const leftIsSigner = isSignerRole(leftEntry.role);
-      if (leftIsSigner !== isSignerRole(rightEntry.role)) {
-        return leftIsSigner ? -1 : 1;
-      }
-      const leftIsWritable = isWritableRole(leftEntry.role);
-      if (leftIsWritable !== isWritableRole(rightEntry.role)) {
-        return leftIsWritable ? -1 : 1;
-      }
-      addressComparator || (addressComparator = getAddressComparator());
-      if (leftEntry[TYPE] === 1 /* LOOKUP_TABLE */ && rightEntry[TYPE] === 1 /* LOOKUP_TABLE */ && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
-        return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
-      } else {
-        return addressComparator(leftAddress, rightAddress);
-      }
-    }).map(([address2, addressMeta]) => ({
-      address: address2,
-      ...addressMeta
-    }));
-    return orderedAccounts;
-  }
-
-  // src/compile-address-table-lookups.ts
-  function getCompiledAddressTableLookups(orderedAccounts) {
-    var _a;
-    const index = {};
-    for (const account of orderedAccounts) {
-      if (!("lookupTableAddress" in account)) {
-        continue;
-      }
-      const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
-        readableIndices: [],
-        writableIndices: []
-      });
-      if (account.role === AccountRole.WRITABLE) {
-        entry.writableIndices.push(account.addressIndex);
-      } else {
-        entry.readableIndices.push(account.addressIndex);
-      }
-    }
-    return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
-      lookupTableAddress,
-      ...index[lookupTableAddress]
-    }));
-  }
-
-  // src/compile-header.ts
-  function getCompiledMessageHeader(orderedAccounts) {
-    let numReadonlyNonSignerAccounts = 0;
-    let numReadonlySignerAccounts = 0;
-    let numSignerAccounts = 0;
-    for (const account of orderedAccounts) {
-      if ("lookupTableAddress" in account) {
-        break;
-      }
-      const accountIsWritable = isWritableRole(account.role);
-      if (isSignerRole(account.role)) {
-        numSignerAccounts++;
-        if (!accountIsWritable) {
-          numReadonlySignerAccounts++;
-        }
-      } else if (!accountIsWritable) {
-        numReadonlyNonSignerAccounts++;
-      }
-    }
-    return {
-      numReadonlyNonSignerAccounts,
-      numReadonlySignerAccounts,
-      numSignerAccounts
-    };
-  }
-
-  // src/compile-instructions.ts
-  function getAccountIndex(orderedAccounts) {
-    const out = {};
-    for (const [index, account] of orderedAccounts.entries()) {
-      out[account.address] = index;
-    }
-    return out;
-  }
-  function getCompiledInstructions(instructions, orderedAccounts) {
-    const accountIndex = getAccountIndex(orderedAccounts);
-    return instructions.map(({ accounts, data, programAddress }) => {
-      return {
-        programAddressIndex: accountIndex[programAddress],
-        ...accounts ? { accountIndices: accounts.map(({ address: address2 }) => accountIndex[address2]) } : null,
-        ...data ? { data } : null
-      };
-    });
-  }
-
-  // src/compile-lifetime-token.ts
-  function getCompiledLifetimeToken(lifetimeConstraint) {
-    if ("nonce" in lifetimeConstraint) {
-      return lifetimeConstraint.nonce;
-    }
-    return lifetimeConstraint.blockhash;
-  }
-
-  // src/compile-static-accounts.ts
-  function getCompiledStaticAccounts(orderedAccounts) {
-    const firstLookupTableAccountIndex = orderedAccounts.findIndex((account) => "lookupTableAddress" in account);
-    const orderedStaticAccounts = firstLookupTableAccountIndex === -1 ? orderedAccounts : orderedAccounts.slice(0, firstLookupTableAccountIndex);
-    return orderedStaticAccounts.map(({ address: address2 }) => address2);
-  }
-
-  // src/message.ts
-  function compileMessage(transaction) {
-    const addressMap = getAddressMapFromInstructions(transaction.feePayer, transaction.instructions);
-    const orderedAccounts = getOrderedAccountsFromAddressMap(addressMap);
-    return {
-      ...transaction.version !== "legacy" ? { addressTableLookups: getCompiledAddressTableLookups(orderedAccounts) } : null,
-      header: getCompiledMessageHeader(orderedAccounts),
-      instructions: getCompiledInstructions(transaction.instructions, orderedAccounts),
-      lifetimeToken: getCompiledLifetimeToken(transaction.lifetimeConstraint),
-      staticAccounts: getCompiledStaticAccounts(orderedAccounts),
-      version: transaction.version
-    };
-  }
-
-  // ../codecs-data-structures/dist/index.browser.js
-  function assertValidNumberOfItemsForCodec(codecDescription, expected, actual) {
-    if (expected !== actual) {
-      throw new Error(`Expected [${codecDescription}] to have ${expected} items, got ${actual}.`);
-    }
-  }
-  function sumCodecSizes(sizes) {
-    return sizes.reduce((all, size) => all === null || size === null ? null : all + size, 0);
-  }
-  function getFixedSize(codec) {
-    return isFixedSize(codec) ? codec.fixedSize : null;
-  }
-  function getMaxSize(codec) {
-    var _a;
-    return isFixedSize(codec) ? codec.fixedSize : (_a = codec.maxSize) != null ? _a : null;
-  }
-  function getArrayEncoder(item, config = {}) {
-    var _a, _b;
-    const size = (_a = config.size) != null ? _a : getU32Encoder();
-    if (size === "remainder") {
-      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-    }
-    const fixedSize = computeArrayLikeCodecSize(size, getFixedSize(item));
-    const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
-    return createEncoder({
-      ...fixedSize !== null ? { fixedSize } : {
-        getSizeFromValue: (array) => {
-          const prefixSize = typeof size === "object" ? getEncodedSize(array.length, size) : 0;
-          return prefixSize + [...array].reduce((all, value) => all + getEncodedSize(value, item), 0);
-        },
-        maxSize
-      },
-      write: (array, bytes, offset) => {
-        if (typeof size === "number") {
-          assertValidNumberOfItemsForCodec("array", size, array.length);
-        }
-        if (typeof size === "object") {
-          offset = size.write(array.length, bytes, offset);
-        }
-        array.forEach((value) => {
-          offset = item.write(value, bytes, offset);
-        });
-        return offset;
-      }
-    });
-  }
-  function getArrayDecoder(item, config = {}) {
-    var _a, _b;
-    const size = (_a = config.size) != null ? _a : getU32Decoder();
-    if (size === "remainder") {
-      assertIsFixedSize(item, 'Codecs of "remainder" size must have fixed-size items.');
-    }
-    const itemSize = getFixedSize(item);
-    const fixedSize = computeArrayLikeCodecSize(size, itemSize);
-    const maxSize = (_b = computeArrayLikeCodecSize(size, getMaxSize(item))) != null ? _b : void 0;
-    return createDecoder({
-      ...fixedSize !== null ? { fixedSize } : { maxSize },
-      read: (bytes, offset) => {
-        const array = [];
-        if (typeof size === "object" && bytes.slice(offset).length === 0) {
-          return [array, offset];
-        }
-        const [resolvedSize, newOffset] = readArrayLikeCodecSize(size, itemSize, bytes, offset);
-        offset = newOffset;
-        for (let i = 0; i < resolvedSize; i += 1) {
-          const [value, newOffset2] = item.read(bytes, offset);
-          offset = newOffset2;
-          array.push(value);
-        }
-        return [array, offset];
-      }
-    });
-  }
-  function readArrayLikeCodecSize(size, itemSize, bytes, offset) {
-    if (typeof size === "number") {
-      return [size, offset];
-    }
-    if (typeof size === "object") {
-      return size.read(bytes, offset);
-    }
-    if (size === "remainder") {
-      if (itemSize === null) {
-        throw new Error('Codecs of "remainder" size must have fixed-size items.');
-      }
-      const remainder = Math.max(0, bytes.length - offset);
-      if (remainder % itemSize !== 0) {
-        throw new Error(
-          `The remainder of the byte array (${remainder} bytes) cannot be split into chunks of ${itemSize} bytes. Codecs of "remainder" size must have a remainder that is a multiple of its item size. In other words, ${remainder} modulo ${itemSize} should be equal to zero.`
-        );
-      }
-      return [remainder / itemSize, offset];
-    }
-    throw new Error(`Unrecognized array-like codec size: ${JSON.stringify(size)}`);
-  }
-  function computeArrayLikeCodecSize(size, itemSize) {
-    if (typeof size !== "number")
-      return null;
-    if (size === 0)
-      return 0;
-    return itemSize === null ? null : itemSize * size;
-  }
-  function getBytesEncoder(config = {}) {
-    var _a;
-    const size = (_a = config.size) != null ? _a : "variable";
-    const byteEncoder = createEncoder({
-      getSizeFromValue: (value) => value.length,
-      write: (value, bytes, offset) => {
-        bytes.set(value, offset);
-        return offset + value.length;
-      }
-    });
-    if (size === "variable") {
-      return byteEncoder;
-    }
-    if (typeof size === "number") {
-      return fixEncoder(byteEncoder, size);
-    }
-    return createEncoder({
-      getSizeFromValue: (value) => getEncodedSize(value.length, size) + value.length,
-      write: (value, bytes, offset) => {
-        offset = size.write(value.length, bytes, offset);
-        return byteEncoder.write(value, bytes, offset);
-      }
-    });
-  }
-  function getBytesDecoder(config = {}) {
-    var _a;
-    const size = (_a = config.size) != null ? _a : "variable";
-    const byteDecoder = createDecoder({
-      read: (bytes, offset) => {
-        const slice = bytes.slice(offset);
-        return [slice, offset + slice.length];
-      }
-    });
-    if (size === "variable") {
-      return byteDecoder;
-    }
-    if (typeof size === "number") {
-      return fixDecoder(byteDecoder, size);
-    }
-    return createDecoder({
-      read: (bytes, offset) => {
-        assertByteArrayIsNotEmptyForCodec("bytes", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.read(bytes, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBytes = bytes.slice(offset, offset + length);
-        assertByteArrayHasEnoughBytesForCodec("bytes", length, contentBytes);
-        const [value, contentOffset] = byteDecoder.read(contentBytes, 0);
-        offset += contentOffset;
-        return [value, offset];
-      }
-    });
-  }
-  function getStructEncoder(fields) {
-    var _a;
-    const fieldCodecs = fields.map(([, codec]) => codec);
-    const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
-    const maxSize = (_a = sumCodecSizes(fieldCodecs.map(getMaxSize))) != null ? _a : void 0;
-    return createEncoder({
-      ...fixedSize === null ? {
-        getSizeFromValue: (value) => fields.map(([key, codec]) => getEncodedSize(value[key], codec)).reduce((all, one) => all + one, 0),
-        maxSize
-      } : { fixedSize },
-      write: (struct, bytes, offset) => {
-        fields.forEach(([key, codec]) => {
-          offset = codec.write(struct[key], bytes, offset);
-        });
-        return offset;
-      }
-    });
-  }
-  function getStructDecoder(fields) {
-    var _a;
-    const fieldCodecs = fields.map(([, codec]) => codec);
-    const fixedSize = sumCodecSizes(fieldCodecs.map(getFixedSize));
-    const maxSize = (_a = sumCodecSizes(fieldCodecs.map(getMaxSize))) != null ? _a : void 0;
-    return createDecoder({
-      ...fixedSize === null ? { maxSize } : { fixedSize },
-      read: (bytes, offset) => {
-        const struct = {};
-        fields.forEach(([key, codec]) => {
-          const [value, newOffset] = codec.read(bytes, offset);
-          offset = newOffset;
-          struct[key] = value;
-        });
-        return [struct, offset];
-      }
-    });
-  }
-
-  // src/serializers/address-table-lookup.ts
-  var memoizedAddressTableLookupEncoder;
-  function getAddressTableLookupEncoder() {
-    if (!memoizedAddressTableLookupEncoder) {
-      memoizedAddressTableLookupEncoder = getStructEncoder([
-        ["lookupTableAddress", getAddressEncoder()],
-        [
-          "writableIndices",
-          getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
-        ],
-        [
-          "readableIndices",
-          getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
-        ]
-      ]);
-    }
-    return memoizedAddressTableLookupEncoder;
-  }
-  var memoizedAddressTableLookupDecoder;
-  function getAddressTableLookupDecoder() {
-    if (!memoizedAddressTableLookupDecoder) {
-      memoizedAddressTableLookupDecoder = getStructDecoder([
-        ["lookupTableAddress", getAddressDecoder()],
-        ["writableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
-        ["readableIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })]
-      ]);
-    }
-    return memoizedAddressTableLookupDecoder;
-  }
-
-  // src/serializers/header.ts
-  var memoizedU8Encoder;
-  function getMemoizedU8Encoder() {
-    if (!memoizedU8Encoder)
-      memoizedU8Encoder = getU8Encoder();
-    return memoizedU8Encoder;
-  }
-  var memoizedU8Decoder;
-  function getMemoizedU8Decoder() {
-    if (!memoizedU8Decoder)
-      memoizedU8Decoder = getU8Decoder();
-    return memoizedU8Decoder;
-  }
-  function getMessageHeaderEncoder() {
-    return getStructEncoder([
-      ["numSignerAccounts", getMemoizedU8Encoder()],
-      ["numReadonlySignerAccounts", getMemoizedU8Encoder()],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
-    ]);
-  }
-  function getMessageHeaderDecoder() {
-    return getStructDecoder([
-      ["numSignerAccounts", getMemoizedU8Decoder()],
-      ["numReadonlySignerAccounts", getMemoizedU8Decoder()],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8Decoder()]
-    ]);
-  }
-
-  // src/serializers/instruction.ts
-  var memoizedGetInstructionEncoder;
-  function getInstructionEncoder() {
-    if (!memoizedGetInstructionEncoder) {
-      memoizedGetInstructionEncoder = mapEncoder(
-        getStructEncoder([
-          ["programAddressIndex", getU8Encoder()],
-          ["accountIndices", getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })],
-          ["data", getBytesEncoder({ size: getShortU16Encoder() })]
-        ]),
-        // Convert an instruction to have all fields defined
-        (instruction) => {
-          var _a, _b;
-          if (instruction.accountIndices !== void 0 && instruction.data !== void 0) {
-            return instruction;
-          }
-          return {
-            ...instruction,
-            accountIndices: (_a = instruction.accountIndices) != null ? _a : [],
-            data: (_b = instruction.data) != null ? _b : new Uint8Array(0)
-          };
-        }
-      );
-    }
-    return memoizedGetInstructionEncoder;
-  }
-  var memoizedGetInstructionDecoder;
-  function getInstructionDecoder() {
-    if (!memoizedGetInstructionDecoder) {
-      memoizedGetInstructionDecoder = mapDecoder(
-        getStructDecoder([
-          ["programAddressIndex", getU8Decoder()],
-          ["accountIndices", getArrayDecoder(getU8Decoder(), { size: getShortU16Decoder() })],
-          ["data", getBytesDecoder({ size: getShortU16Decoder() })]
-        ]),
-        // Convert an instruction to exclude optional fields if they are empty
-        (instruction) => {
-          if (instruction.accountIndices.length && instruction.data.byteLength) {
-            return instruction;
-          }
-          const { accountIndices, data, ...rest } = instruction;
-          return {
-            ...rest,
-            ...accountIndices.length ? { accountIndices } : null,
-            ...data.byteLength ? { data } : null
-          };
-        }
-      );
-    }
-    return memoizedGetInstructionDecoder;
-  }
-
-  // src/serializers/transaction-version.ts
-  var VERSION_FLAG_MASK = 128;
-  function getTransactionVersionEncoder() {
-    return createEncoder({
-      getSizeFromValue: (value) => value === "legacy" ? 0 : 1,
-      maxSize: 1,
-      write: (value, bytes, offset) => {
-        if (value === "legacy") {
-          return offset;
-        }
-        if (value < 0 || value > 127) {
-          throw new Error(`Transaction version must be in the range [0, 127]. \`${value}\` given.`);
-        }
-        bytes.set([value | VERSION_FLAG_MASK], offset);
-        return offset + 1;
-      }
-    });
-  }
-  function getTransactionVersionDecoder() {
-    return createDecoder({
-      maxSize: 1,
-      read: (bytes, offset) => {
-        const firstByte = bytes[offset];
-        if ((firstByte & VERSION_FLAG_MASK) === 0) {
-          return ["legacy", offset];
-        } else {
-          const version = firstByte ^ VERSION_FLAG_MASK;
-          return [version, offset + 1];
-        }
-      }
-    });
-  }
-
-  // src/serializers/message.ts
-  function getCompiledMessageLegacyEncoder() {
-    return getStructEncoder(getPreludeStructEncoderTuple());
-  }
-  function getCompiledMessageVersionedEncoder() {
-    return mapEncoder(
-      getStructEncoder([
-        ...getPreludeStructEncoderTuple(),
-        ["addressTableLookups", getAddressTableLookupArrayEncoder()]
-      ]),
-      (value) => {
-        var _a;
-        if (value.version === "legacy") {
-          return value;
-        }
-        return {
-          ...value,
-          addressTableLookups: (_a = value.addressTableLookups) != null ? _a : []
-        };
-      }
-    );
-  }
-  function getPreludeStructEncoderTuple() {
-    return [
-      ["version", getTransactionVersionEncoder()],
-      ["header", getMessageHeaderEncoder()],
-      ["staticAccounts", getArrayEncoder(getAddressEncoder(), { size: getShortU16Encoder() })],
-      ["lifetimeToken", getStringEncoder({ encoding: getBase58Encoder(), size: 32 })],
-      ["instructions", getArrayEncoder(getInstructionEncoder(), { size: getShortU16Encoder() })]
-    ];
-  }
-  function getPreludeStructDecoderTuple() {
-    return [
-      ["version", getTransactionVersionDecoder()],
-      ["header", getMessageHeaderDecoder()],
-      ["staticAccounts", getArrayDecoder(getAddressDecoder(), { size: getShortU16Decoder() })],
-      ["lifetimeToken", getStringDecoder({ encoding: getBase58Decoder(), size: 32 })],
-      ["instructions", getArrayDecoder(getInstructionDecoder(), { size: getShortU16Decoder() })],
-      ["addressTableLookups", getAddressTableLookupArrayDecoder()]
-    ];
-  }
-  function getAddressTableLookupArrayEncoder() {
-    return getArrayEncoder(getAddressTableLookupEncoder(), { size: getShortU16Encoder() });
-  }
-  function getAddressTableLookupArrayDecoder() {
-    return getArrayDecoder(getAddressTableLookupDecoder(), { size: getShortU16Decoder() });
-  }
-  function getCompiledMessageEncoder() {
-    return createEncoder({
-      getSizeFromValue: (compiledMessage) => {
-        if (compiledMessage.version === "legacy") {
-          return getCompiledMessageLegacyEncoder().getSizeFromValue(compiledMessage);
-        } else {
-          return getCompiledMessageVersionedEncoder().getSizeFromValue(compiledMessage);
-        }
-      },
-      write: (compiledMessage, bytes, offset) => {
-        if (compiledMessage.version === "legacy") {
-          return getCompiledMessageLegacyEncoder().write(compiledMessage, bytes, offset);
-        } else {
-          return getCompiledMessageVersionedEncoder().write(compiledMessage, bytes, offset);
-        }
-      }
-    });
-  }
-  function getCompiledMessageDecoder() {
-    return mapDecoder(getStructDecoder(getPreludeStructDecoderTuple()), ({ addressTableLookups, ...restOfMessage }) => {
-      if (restOfMessage.version === "legacy" || !(addressTableLookups == 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
-  function getCompiledTransactionEncoder() {
-    return getStructEncoder([
-      ["signatures", getArrayEncoder(getBytesEncoder({ size: 64 }), { size: getShortU16Encoder() })],
-      ["compiledMessage", getCompiledMessageEncoder()]
-    ]);
-  }
-  function getCompiledTransactionDecoder() {
-    return getStructDecoder([
-      [
-        "signatures",
-        getArrayDecoder(getBytesDecoder({ size: 64 }), {
-          size: getShortU16Decoder()
-        })
-      ],
-      ["compiledMessage", getCompiledMessageDecoder()]
-    ]);
-  }
-  function getTransactionEncoder() {
-    return mapEncoder(getCompiledTransactionEncoder(), getCompiledTransaction);
-  }
-  function getTransactionDecoder(lastValidBlockHeight) {
-    return mapDecoder(
-      getCompiledTransactionDecoder(),
-      (compiledTransaction) => decompileTransaction(compiledTransaction, lastValidBlockHeight)
-    );
-  }
-  function getTransactionCodec(lastValidBlockHeight) {
-    return combineCodec(getTransactionEncoder(), getTransactionDecoder(lastValidBlockHeight));
-  }
-
-  // ../keys/dist/index.browser.js
-  async function signBytes(key, data) {
-    await assertSigningCapabilityIsAvailable();
-    const signedData = await crypto.subtle.sign("Ed25519", key, data);
-    return new Uint8Array(signedData);
-  }
-
-  // src/signatures.ts
-  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 transactionSignature = base58Decoder.decode(signatureBytes);
-    return transactionSignature;
-  }
-  async function partiallySignTransaction(keyPairs, transaction) {
-    const compiledMessage = compileMessage(transaction);
-    const nextSignatures = "signatures" in transaction ? { ...transaction.signatures } : {};
-    const wireMessageBytes = getCompiledMessageEncoder().encode(compiledMessage);
-    const publicKeySignaturePairs = await Promise.all(
-      keyPairs.map(
-        (keyPair) => Promise.all([getAddressFromPublicKey(keyPair.publicKey), signBytes(keyPair.privateKey, wireMessageBytes)])
-      )
-    );
-    for (const [signerPublicKey, signature] of publicKeySignaturePairs) {
-      nextSignatures[signerPublicKey] = signature;
-    }
-    const out = {
-      ...transaction,
-      signatures: nextSignatures
-    };
-    Object.freeze(out);
-    return out;
-  }
-  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) => {
-      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]) {
-        throw new Error(`Transaction is missing signature for address \`${address2}\``);
-      }
-    });
-  }
-
-  // src/wire-transaction.ts
-  function getBase64EncodedWireTransaction(transaction) {
-    const wireTransactionBytes = getTransactionEncoder().encode(transaction);
-    return getBase64Decoder().decode(wireTransactionBytes);
-  }
-
-  exports.appendTransactionInstruction = appendTransactionInstruction;
-  exports.assertIsBlockhash = assertIsBlockhash;
-  exports.assertIsDurableNonceTransaction = assertIsDurableNonceTransaction;
-  exports.assertIsTransactionWithBlockhashLifetime = assertIsTransactionWithBlockhashLifetime;
-  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;
-
-  return exports;
-
-})({});
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.development.js.map