@solana/signers 2.0.0-experimental.fcff844 → 2.0.0-experimental.feaeef2

package/dist/index.development.js

@@ -1,1350 +0,0 @@
-this.globalThis = this.globalThis || {};
-this.globalThis.solanaWeb3 = (function (exports) {
-  'use strict';
-
-  // src/deduplicate-signers.ts
-  function deduplicateSigners(signers) {
-    const deduplicated = {};
-    signers.forEach((signer) => {
-      if (!deduplicated[signer.address]) {
-        deduplicated[signer.address] = signer;
-      } else if (deduplicated[signer.address] !== signer) {
-        throw new Error(
-          `Multiple distinct signers were identified for address "${signer.address}". Please ensure that you are using the same signer instance for each address.`
-        );
-      }
-    });
-    return Object.values(deduplicated);
-  }
-
-  // src/account-signer-meta.ts
-  function getSignersFromInstruction(instruction) {
-    var _a;
-    return deduplicateSigners(
-      ((_a = instruction.accounts) != null ? _a : []).flatMap((account) => "signer" in account ? account.signer : [])
-    );
-  }
-  function getSignersFromTransaction(transaction) {
-    return deduplicateSigners(transaction.instructions.flatMap(getSignersFromInstruction));
-  }
-
-  // ../instructions/dist/index.browser.js
-  function isSignerRole(role) {
-    return role >= 2;
-  }
-
-  // src/add-signers.ts
-  function addSignersToInstruction(signers, instruction) {
-    if (!instruction.accounts || instruction.accounts.length === 0) {
-      return instruction;
-    }
-    const signerByAddress = new Map(deduplicateSigners(signers).map((signer) => [signer.address, signer]));
-    return Object.freeze({
-      ...instruction,
-      accounts: instruction.accounts.map((account) => {
-        const signer = signerByAddress.get(account.address);
-        if (!isSignerRole(account.role) || "signer" in account || !signer) {
-          return account;
-        }
-        return Object.freeze({ ...account, signer });
-      })
-    });
-  }
-  function addSignersToTransaction(signers, transaction) {
-    if (transaction.instructions.length === 0) {
-      return transaction;
-    }
-    return Object.freeze({
-      ...transaction,
-      instructions: transaction.instructions.map((instruction) => addSignersToInstruction(signers, instruction))
-    });
-  }
-
-  // ../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 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)
-    });
-  }
-
-  // ../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 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
-  });
-
-  // ../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 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];
-      }
-    });
-  }
-
-  // ../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"
-      );
-    }
-  }
-  var cachedEd25519Decision;
-  async function isEd25519CurveSupported(subtle) {
-    if (cachedEd25519Decision === void 0) {
-      cachedEd25519Decision = new Promise((resolve) => {
-        subtle.generateKey(
-          "Ed25519",
-          /* extractable */
-          false,
-          ["sign", "verify"]
-        ).catch(() => {
-          resolve(cachedEd25519Decision = false);
-        }).then(() => {
-          resolve(cachedEd25519Decision = true);
-        });
-      });
-    }
-    if (typeof cachedEd25519Decision === "boolean") {
-      return cachedEd25519Decision;
-    } else {
-      return await cachedEd25519Decision;
-    }
-  }
-  async function assertKeyGenerationIsAvailable() {
-    var _a;
-    assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.generateKey) !== "function") {
-      throw new Error("No key generation implementation could be found");
-    }
-    if (!await isEd25519CurveSupported(globalThis.crypto.subtle)) {
-      throw new Error(
-        "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall and import `@solana/webcrypto-ed25519-polyfill` before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20"
-      );
-    }
-  }
-  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 isAddress(putativeAddress) {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeAddress.length > 44
-    ) {
-      return false;
-    }
-    const base58Encoder = getMemoizedBase58Encoder();
-    const bytes = base58Encoder.encode(putativeAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      return false;
-    }
-    return true;
-  }
-  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 base58Encoder = getMemoizedBase58Encoder();
-      const bytes = base58Encoder.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 (e3) {
-      throw new Error(`\`${putativeAddress}\` is not a base-58 encoded address`, {
-        cause: e3
-      });
-    }
-  }
-  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));
-  }
-
-  // ../keys/dist/index.browser.js
-  async function generateKeyPair() {
-    await assertKeyGenerationIsAvailable();
-    const keyPair = await crypto.subtle.generateKey(
-      /* algorithm */
-      "Ed25519",
-      // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20
-      /* extractable */
-      false,
-      // Prevents the bytes of the private key from being visible to JS.
-      /* allowed uses */
-      ["sign", "verify"]
-    );
-    return keyPair;
-  }
-  async function signBytes(key, data) {
-    await assertSigningCapabilityIsAvailable();
-    const signedData = await crypto.subtle.sign("Ed25519", key, data);
-    return new Uint8Array(signedData);
-  }
-
-  // ../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 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 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;
-      }
-    });
-  }
-
-  // ../transactions/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 isSignerRole2(role) {
-    return role >= 2;
-  }
-  function isWritableRole(role) {
-    return (role & IS_WRITABLE_BITMASK) !== 0;
-  }
-  function mergeRoles(roleA, roleB) {
-    return roleA | roleB;
-  }
-  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, 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:
-                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) {
-            return entry;
-          }
-        }
-        return { [TYPE]: 2, 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:
-                return entry;
-              case 1: {
-                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,
-                      ...accountMeta,
-                      role: nextRole
-                    };
-                  }
-                } else if (isSignerRole2(accountMeta.role)) {
-                  return {
-                    [TYPE]: 2,
-                    role: nextRole
-                  };
-                }
-                if (entry.role !== nextRole) {
-                  return {
-                    ...entry,
-                    role: nextRole
-                  };
-                } else {
-                  return entry;
-                }
-              }
-              case 2: {
-                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.
-                !isSignerRole2(entry.role)) {
-                  return {
-                    ...accountMeta,
-                    [TYPE]: 1,
-                    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) {
-          return -1;
-        } else if (rightEntry[TYPE] === 0) {
-          return 1;
-        } else if (leftEntry[TYPE] === 2) {
-          return -1;
-        } else if (rightEntry[TYPE] === 2) {
-          return 1;
-        }
-      }
-      const leftIsSigner = isSignerRole2(leftEntry.role);
-      if (leftIsSigner !== isSignerRole2(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 && rightEntry[TYPE] === 1 && leftEntry.lookupTableAddress !== rightEntry.lookupTableAddress) {
-        return addressComparator(leftEntry.lookupTableAddress, rightEntry.lookupTableAddress);
-      } else {
-        return addressComparator(leftAddress, rightAddress);
-      }
-    }).map(([address2, addressMeta]) => ({
-      address: address2,
-      ...addressMeta
-    }));
-    return orderedAccounts;
-  }
-  function getCompiledAddressTableLookups(orderedAccounts) {
-    var _a;
-    const index = {};
-    for (const account of orderedAccounts) {
-      if (!("lookupTableAddress" in account)) {
-        continue;
-      }
-      const entry = index[_a = account.lookupTableAddress] || (index[_a] = {
-        readableIndices: [],
-        writableIndices: []
-      });
-      if (account.role === AccountRole.WRITABLE) {
-        entry.writableIndices.push(account.addressIndex);
-      } else {
-        entry.readableIndices.push(account.addressIndex);
-      }
-    }
-    return Object.keys(index).sort(getAddressComparator()).map((lookupTableAddress) => ({
-      lookupTableAddress,
-      ...index[lookupTableAddress]
-    }));
-  }
-  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 (isSignerRole2(account.role)) {
-        numSignerAccounts++;
-        if (!accountIsWritable) {
-          numReadonlySignerAccounts++;
-        }
-      } else if (!accountIsWritable) {
-        numReadonlyNonSignerAccounts++;
-      }
-    }
-    return {
-      numReadonlyNonSignerAccounts,
-      numReadonlySignerAccounts,
-      numSignerAccounts
-    };
-  }
-  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
-      };
-    });
-  }
-  function getCompiledLifetimeToken(lifetimeConstraint) {
-    if ("nonce" in lifetimeConstraint) {
-      return lifetimeConstraint.nonce;
-    }
-    return lifetimeConstraint.blockhash;
-  }
-  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);
-  }
-  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
-    };
-  }
-  var memoizedAddressTableLookupEncoder;
-  function getAddressTableLookupEncoder() {
-    if (!memoizedAddressTableLookupEncoder) {
-      memoizedAddressTableLookupEncoder = getStructEncoder([
-        ["lookupTableAddress", getAddressEncoder()],
-        [
-          "writableIndices",
-          getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
-        ],
-        [
-          "readableIndices",
-          getArrayEncoder(getU8Encoder(), { size: getShortU16Encoder() })
-        ]
-      ]);
-    }
-    return memoizedAddressTableLookupEncoder;
-  }
-  var memoizedU8Encoder;
-  function getMemoizedU8Encoder() {
-    if (!memoizedU8Encoder)
-      memoizedU8Encoder = getU8Encoder();
-    return memoizedU8Encoder;
-  }
-  function getMessageHeaderEncoder() {
-    return getStructEncoder([
-      ["numSignerAccounts", getMemoizedU8Encoder()],
-      ["numReadonlySignerAccounts", getMemoizedU8Encoder()],
-      ["numReadonlyNonSignerAccounts", getMemoizedU8Encoder()]
-    ]);
-  }
-  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 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 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 getAddressTableLookupArrayEncoder() {
-    return getArrayEncoder(getAddressTableLookupEncoder(), { size: getShortU16Encoder() });
-  }
-  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);
-        }
-      }
-    });
-  }
-  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;
-  }
-  function assertTransactionIsFullySigned(transaction) {
-    const signerAddressesFromInstructions = transaction.instructions.flatMap((i) => {
-      var _a, _b;
-      return (_b = (_a = i.accounts) == null ? void 0 : _a.filter((a) => isSignerRole2(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/message-partial-signer.ts
-  function isMessagePartialSigner(value) {
-    return "signMessages" in value && typeof value.signMessages === "function";
-  }
-  function assertIsMessagePartialSigner(value) {
-    if (!isMessagePartialSigner(value)) {
-      throw new Error("The provided value does not implement the MessagePartialSigner interface");
-    }
-  }
-
-  // src/transaction-partial-signer.ts
-  function isTransactionPartialSigner(value) {
-    return "signTransactions" in value && typeof value.signTransactions === "function";
-  }
-  function assertIsTransactionPartialSigner(value) {
-    if (!isTransactionPartialSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionPartialSigner interface");
-    }
-  }
-
-  // src/keypair-signer.ts
-  function isKeyPairSigner(value) {
-    return "keyPair" in value && typeof value.keyPair === "object" && isMessagePartialSigner(value) && isTransactionPartialSigner(value);
-  }
-  function assertIsKeyPairSigner(value) {
-    if (!isKeyPairSigner(value)) {
-      throw new Error("The provided value does not implement the KeyPairSigner interface");
-    }
-  }
-  async function createSignerFromKeyPair(keyPair) {
-    const address2 = await getAddressFromPublicKey(keyPair.publicKey);
-    const out = {
-      address: address2,
-      keyPair,
-      signMessages: (messages) => Promise.all(
-        messages.map(
-          async (message) => Object.freeze({ [address2]: await signBytes(keyPair.privateKey, message.content) })
-        )
-      ),
-      signTransactions: (transactions) => Promise.all(
-        transactions.map(async (transaction) => {
-          const signedTransaction = await partiallySignTransaction([keyPair], transaction);
-          return Object.freeze({ [address2]: signedTransaction.signatures[address2] });
-        })
-      )
-    };
-    return Object.freeze(out);
-  }
-  async function generateKeyPairSigner() {
-    return createSignerFromKeyPair(await generateKeyPair());
-  }
-
-  // src/message-modifying-signer.ts
-  function isMessageModifyingSigner(value) {
-    return isAddress(value.address) && "modifyAndSignMessages" in value && typeof value.modifyAndSignMessages === "function";
-  }
-  function assertIsMessageModifyingSigner(value) {
-    if (!isMessageModifyingSigner(value)) {
-      throw new Error("The provided value does not implement the MessageModifyingSigner interface");
-    }
-  }
-
-  // src/message-signer.ts
-  function isMessageSigner(value) {
-    return isMessagePartialSigner(value) || isMessageModifyingSigner(value);
-  }
-  function assertIsMessageSigner(value) {
-    if (!isMessageSigner(value)) {
-      throw new Error("The provided value does not implement any of the MessageSigner interfaces");
-    }
-  }
-
-  // src/noop-signer.ts
-  function createNoopSigner(address2) {
-    const out = {
-      address: address2,
-      signMessages: async (messages) => messages.map(() => Object.freeze({})),
-      signTransactions: async (transactions) => transactions.map(() => Object.freeze({}))
-    };
-    return Object.freeze(out);
-  }
-
-  // src/transaction-modifying-signer.ts
-  function isTransactionModifyingSigner(value) {
-    return "modifyAndSignTransactions" in value && typeof value.modifyAndSignTransactions === "function";
-  }
-  function assertIsTransactionModifyingSigner(value) {
-    if (!isTransactionModifyingSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionModifyingSigner interface");
-    }
-  }
-
-  // src/transaction-sending-signer.ts
-  function isTransactionSendingSigner(value) {
-    return "signAndSendTransactions" in value && typeof value.signAndSendTransactions === "function";
-  }
-  function assertIsTransactionSendingSigner(value) {
-    if (!isTransactionSendingSigner(value)) {
-      throw new Error("The provided value does not implement the TransactionSendingSigner interface");
-    }
-  }
-
-  // src/transaction-signer.ts
-  function isTransactionSigner(value) {
-    return isTransactionPartialSigner(value) || isTransactionModifyingSigner(value) || isTransactionSendingSigner(value);
-  }
-  function assertIsTransactionSigner(value) {
-    if (!isTransactionSigner(value)) {
-      throw new Error("The provided value does not implement any of the TransactionSigner interfaces");
-    }
-  }
-
-  // src/sign-transaction.ts
-  async function partiallySignTransactionWithSigners(transaction, config = {}) {
-    const { partialSigners, modifyingSigners } = categorizeTransactionSigners(
-      deduplicateSigners(getSignersFromTransaction(transaction).filter(isTransactionSigner)),
-      { identifySendingSigner: false }
-    );
-    return signModifyingAndPartialTransactionSigners(transaction, modifyingSigners, partialSigners, config.abortSignal);
-  }
-  async function signTransactionWithSigners(transaction, config = {}) {
-    const signedTransaction = await partiallySignTransactionWithSigners(transaction, config);
-    assertTransactionIsFullySigned(signedTransaction);
-    return signedTransaction;
-  }
-  async function signAndSendTransactionWithSigners(transaction, config = {}) {
-    const abortSignal = config.abortSignal;
-    const { partialSigners, modifyingSigners, sendingSigner } = categorizeTransactionSigners(
-      deduplicateSigners(getSignersFromTransaction(transaction).filter(isTransactionSigner))
-    );
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
-    const signedTransaction = await signModifyingAndPartialTransactionSigners(
-      transaction,
-      modifyingSigners,
-      partialSigners,
-      abortSignal
-    );
-    if (!sendingSigner) {
-      throw new Error(
-        "No `TransactionSendingSigner` was identified. Please provide a valid `ITransactionWithSingleSendingSigner` transaction."
-      );
-    }
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
-    const [signature] = await sendingSigner.signAndSendTransactions([signedTransaction], { abortSignal });
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
-    return signature;
-  }
-  function categorizeTransactionSigners(signers, config = {}) {
-    var _a;
-    const identifySendingSigner = (_a = config.identifySendingSigner) != null ? _a : true;
-    const sendingSigner = identifySendingSigner ? identifyTransactionSendingSigner(signers) : null;
-    const otherSigners = signers.filter(
-      (signer) => signer !== sendingSigner && (isTransactionModifyingSigner(signer) || isTransactionPartialSigner(signer))
-    );
-    const modifyingSigners = identifyTransactionModifyingSigners(otherSigners);
-    const partialSigners = otherSigners.filter(isTransactionPartialSigner).filter((signer) => !modifyingSigners.includes(signer));
-    return Object.freeze({ modifyingSigners, partialSigners, sendingSigner });
-  }
-  function identifyTransactionSendingSigner(signers) {
-    const sendingSigners = signers.filter(isTransactionSendingSigner);
-    if (sendingSigners.length === 0)
-      return null;
-    const sendingOnlySigners = sendingSigners.filter(
-      (signer) => !isTransactionModifyingSigner(signer) && !isTransactionPartialSigner(signer)
-    );
-    if (sendingOnlySigners.length > 0) {
-      return sendingOnlySigners[0];
-    }
-    return sendingSigners[0];
-  }
-  function identifyTransactionModifyingSigners(signers) {
-    const modifyingSigners = signers.filter(isTransactionModifyingSigner);
-    if (modifyingSigners.length === 0)
-      return [];
-    const nonPartialSigners = modifyingSigners.filter((signer) => !isTransactionPartialSigner(signer));
-    if (nonPartialSigners.length > 0)
-      return nonPartialSigners;
-    return [modifyingSigners[0]];
-  }
-  async function signModifyingAndPartialTransactionSigners(transaction, modifyingSigners = [], partialSigners = [], abortSignal) {
-    var _a;
-    const modifiedTransaction = await modifyingSigners.reduce(
-      async (transaction2, modifyingSigner) => {
-        abortSignal == null ? void 0 : abortSignal.throwIfAborted();
-        const [tx] = await modifyingSigner.modifyAndSignTransactions([await transaction2], { abortSignal });
-        return Object.freeze(tx);
-      },
-      Promise.resolve(transaction)
-    );
-    abortSignal == null ? void 0 : abortSignal.throwIfAborted();
-    const signatureDictionaries = await Promise.all(
-      partialSigners.map(async (partialSigner) => {
-        const [signatures] = await partialSigner.signTransactions([modifiedTransaction], { abortSignal });
-        return signatures;
-      })
-    );
-    const signedTransaction = {
-      ...modifiedTransaction,
-      signatures: Object.freeze(
-        signatureDictionaries.reduce((signatures, signatureDictionary) => {
-          return { ...signatures, ...signatureDictionary };
-        }, (_a = modifiedTransaction.signatures) != null ? _a : {})
-      )
-    };
-    return Object.freeze(signedTransaction);
-  }
-  var o2 = globalThis.TextEncoder;
-
-  // src/signable-message.ts
-  function createSignableMessage(content, signatures = {}) {
-    return Object.freeze({
-      content: typeof content === "string" ? new o2().encode(content) : content,
-      signatures: Object.freeze({ ...signatures })
-    });
-  }
-
-  // src/transaction-with-single-sending-signer.ts
-  function isTransactionWithSingleSendingSigner(transaction) {
-    try {
-      assertIsTransactionWithSingleSendingSigner(transaction);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  function assertIsTransactionWithSingleSendingSigner(transaction) {
-    const signers = getSignersFromTransaction(transaction);
-    const sendingSigners = signers.filter(isTransactionSendingSigner);
-    if (sendingSigners.length === 0) {
-      const error = new Error("No `TransactionSendingSigner` was identified.");
-      error.name = "MissingTransactionSendingSignerError";
-      throw error;
-    }
-    const sendingOnlySigners = sendingSigners.filter(
-      (signer) => !isTransactionPartialSigner(signer) && !isTransactionModifyingSigner(signer)
-    );
-    if (sendingOnlySigners.length > 1) {
-      const error = new Error("More than one `TransactionSendingSigner` was identified.");
-      error.name = "MultipleTransactionSendingSignersError";
-      throw error;
-    }
-  }
-
-  exports.addSignersToInstruction = addSignersToInstruction;
-  exports.addSignersToTransaction = addSignersToTransaction;
-  exports.assertIsKeyPairSigner = assertIsKeyPairSigner;
-  exports.assertIsMessageModifyingSigner = assertIsMessageModifyingSigner;
-  exports.assertIsMessagePartialSigner = assertIsMessagePartialSigner;
-  exports.assertIsMessageSigner = assertIsMessageSigner;
-  exports.assertIsTransactionModifyingSigner = assertIsTransactionModifyingSigner;
-  exports.assertIsTransactionPartialSigner = assertIsTransactionPartialSigner;
-  exports.assertIsTransactionSendingSigner = assertIsTransactionSendingSigner;
-  exports.assertIsTransactionSigner = assertIsTransactionSigner;
-  exports.assertIsTransactionWithSingleSendingSigner = assertIsTransactionWithSingleSendingSigner;
-  exports.createNoopSigner = createNoopSigner;
-  exports.createSignableMessage = createSignableMessage;
-  exports.createSignerFromKeyPair = createSignerFromKeyPair;
-  exports.generateKeyPairSigner = generateKeyPairSigner;
-  exports.getSignersFromInstruction = getSignersFromInstruction;
-  exports.getSignersFromTransaction = getSignersFromTransaction;
-  exports.isKeyPairSigner = isKeyPairSigner;
-  exports.isMessageModifyingSigner = isMessageModifyingSigner;
-  exports.isMessagePartialSigner = isMessagePartialSigner;
-  exports.isMessageSigner = isMessageSigner;
-  exports.isTransactionModifyingSigner = isTransactionModifyingSigner;
-  exports.isTransactionPartialSigner = isTransactionPartialSigner;
-  exports.isTransactionSendingSigner = isTransactionSendingSigner;
-  exports.isTransactionSigner = isTransactionSigner;
-  exports.isTransactionWithSingleSendingSigner = isTransactionWithSingleSendingSigner;
-  exports.partiallySignTransactionWithSigners = partiallySignTransactionWithSigners;
-  exports.signAndSendTransactionWithSigners = signAndSendTransactionWithSigners;
-  exports.signTransactionWithSigners = signTransactionWithSigners;
-
-  return exports;
-
-})({});
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.development.js.map