@solana/addresses 2.0.0-experimental.fe07532 → 2.0.0-experimental.feaeef2

package/dist/index.development.js

@@ -1,663 +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 mergeBytes = (byteArrays) => {
-    const nonEmptyByteArrays = byteArrays.filter((arr) => arr.length);
-    if (nonEmptyByteArrays.length === 0) {
-      return byteArrays.length ? byteArrays[0] : new Uint8Array();
-    }
-    if (nonEmptyByteArrays.length === 1) {
-      return nonEmptyByteArrays[0];
-    }
-    const totalLength = nonEmptyByteArrays.reduce((total, arr) => total + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    nonEmptyByteArrays.forEach((arr) => {
-      result.set(arr, offset);
-      offset += arr.length;
-    });
-    return result;
-  };
-  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 combineCodec(encoder, decoder, description) {
-    if (encoder.fixedSize !== decoder.fixedSize) {
-      throw new Error(
-        `Encoder and decoder must have the same fixed size, got [${encoder.fixedSize}] and [${decoder.fixedSize}].`
-      );
-    }
-    if (encoder.maxSize !== decoder.maxSize) {
-      throw new Error(
-        `Encoder and decoder must have the same max size, got [${encoder.maxSize}] and [${decoder.maxSize}].`
-      );
-    }
-    if (description === void 0 && encoder.description !== decoder.description) {
-      throw new Error(
-        `Encoder and decoder must have the same description, got [${encoder.description}] and [${decoder.description}]. Pass a custom description as a third argument if you want to override the description and bypass this error.`
-      );
-    }
-    return {
-      decode: decoder.decode,
-      description: description ?? encoder.description,
-      encode: encoder.encode,
-      fixedSize: encoder.fixedSize,
-      maxSize: encoder.maxSize
-    };
-  }
-  function fixCodecHelper(data, fixedBytes, description) {
-    return {
-      description: description ?? `fixed(${fixedBytes}, ${data.description})`,
-      fixedSize: fixedBytes,
-      maxSize: fixedBytes
-    };
-  }
-  function fixEncoder(encoder, fixedBytes, description) {
-    return {
-      ...fixCodecHelper(encoder, fixedBytes, description),
-      encode: (value) => fixBytes(encoder.encode(value), fixedBytes)
-    };
-  }
-  function fixDecoder(decoder, fixedBytes, description) {
-    return {
-      ...fixCodecHelper(decoder, fixedBytes, description),
-      decode: (bytes, offset = 0) => {
-        assertByteArrayHasEnoughBytesForCodec("fixCodec", fixedBytes, bytes, offset);
-        if (offset > 0 || bytes.length > fixedBytes) {
-          bytes = bytes.slice(offset, offset + fixedBytes);
-        }
-        if (decoder.fixedSize !== null) {
-          bytes = fixBytes(bytes, decoder.fixedSize);
-        }
-        const [value] = decoder.decode(bytes, 0);
-        return [value, offset + fixedBytes];
-      }
-    };
-  }
-  function mapEncoder(encoder, unmap) {
-    return {
-      description: encoder.description,
-      encode: (value) => encoder.encode(unmap(value)),
-      fixedSize: encoder.fixedSize,
-      maxSize: encoder.maxSize
-    };
-  }
-
-  // ../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 sharedNumberFactory(input) {
-    let littleEndian;
-    let defaultDescription = input.name;
-    if (input.size > 1) {
-      littleEndian = !("endian" in input.options) || input.options.endian === 0;
-      defaultDescription += littleEndian ? "(le)" : "(be)";
-    }
-    return {
-      description: input.options.description ?? defaultDescription,
-      fixedSize: input.size,
-      littleEndian,
-      maxSize: input.size
-    };
-  }
-  function numberEncoderFactory(input) {
-    const codecData = sharedNumberFactory(input);
-    return {
-      description: codecData.description,
-      encode(value) {
-        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, codecData.littleEndian);
-        return new Uint8Array(arrayBuffer);
-      },
-      fixedSize: codecData.fixedSize,
-      maxSize: codecData.maxSize
-    };
-  }
-  function numberDecoderFactory(input) {
-    const codecData = sharedNumberFactory(input);
-    return {
-      decode(bytes, offset = 0) {
-        assertByteArrayIsNotEmptyForCodec(codecData.description, bytes, offset);
-        assertByteArrayHasEnoughBytesForCodec(codecData.description, input.size, bytes, offset);
-        const view = new DataView(toArrayBuffer(bytes, offset, input.size));
-        return [input.get(view, codecData.littleEndian), offset + input.size];
-      },
-      description: codecData.description,
-      fixedSize: codecData.fixedSize,
-      maxSize: codecData.maxSize
-    };
-  }
-  function toArrayBuffer(bytes, offset, length) {
-    const bytesOffset = bytes.byteOffset + (offset ?? 0);
-    const bytesLength = length ?? bytes.byteLength;
-    return bytes.buffer.slice(bytesOffset, bytesOffset + bytesLength);
-  }
-  var getU32Encoder = (options = {}) => numberEncoderFactory({
-    name: "u32",
-    options,
-    range: [0, Number("0xffffffff")],
-    set: (view, value, le) => view.setUint32(0, value, le),
-    size: 4
-  });
-  var getU32Decoder = (options = {}) => numberDecoderFactory({
-    get: (view, le) => view.getUint32(0, le),
-    name: "u32",
-    options,
-    size: 4
-  });
-
-  // ../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) => {
-    const base = alphabet4.length;
-    const baseBigInt = BigInt(base);
-    return {
-      description: `base${base}`,
-      encode(value) {
-        assertValidBaseString(alphabet4, value);
-        if (value === "")
-          return new Uint8Array();
-        const chars = [...value];
-        let trailIndex = chars.findIndex((c) => c !== alphabet4[0]);
-        trailIndex = trailIndex === -1 ? chars.length : trailIndex;
-        const leadingZeroes = Array(trailIndex).fill(0);
-        if (trailIndex === chars.length)
-          return Uint8Array.from(leadingZeroes);
-        const tailChars = chars.slice(trailIndex);
-        let base10Number = 0n;
-        let baseXPower = 1n;
-        for (let i = tailChars.length - 1; i >= 0; i -= 1) {
-          base10Number += baseXPower * BigInt(alphabet4.indexOf(tailChars[i]));
-          baseXPower *= baseBigInt;
-        }
-        const tailBytes = [];
-        while (base10Number > 0n) {
-          tailBytes.unshift(Number(base10Number % 256n));
-          base10Number /= 256n;
-        }
-        return Uint8Array.from(leadingZeroes.concat(tailBytes));
-      },
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  var getBaseXDecoder = (alphabet4) => {
-    const base = alphabet4.length;
-    const baseBigInt = BigInt(base);
-    return {
-      decode(rawBytes, offset = 0) {
-        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];
-        let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
-        const tailChars = [];
-        while (base10Number > 0n) {
-          tailChars.unshift(alphabet4[Number(base10Number % baseBigInt)]);
-          base10Number /= baseBigInt;
-        }
-        return [leadingZeroes + tailChars.join(""), rawBytes.length];
-      },
-      description: `base${base}`,
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  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 {
-      description: "utf8",
-      encode: (value) => new Uint8Array((textEncoder || (textEncoder = new o())).encode(value)),
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  var getUtf8Decoder = () => {
-    let textDecoder;
-    return {
-      decode(bytes, offset = 0) {
-        const value = (textDecoder || (textDecoder = new e())).decode(bytes.slice(offset));
-        return [removeNullCharacters(value), bytes.length];
-      },
-      description: "utf8",
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  var getStringEncoder = (options = {}) => {
-    const size = options.size ?? getU32Encoder();
-    const encoding = options.encoding ?? getUtf8Encoder();
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
-    if (size === "variable") {
-      return { ...encoding, description };
-    }
-    if (typeof size === "number") {
-      return fixEncoder(encoding, size, description);
-    }
-    return {
-      description,
-      encode: (value) => {
-        const contentBytes = encoding.encode(value);
-        const lengthBytes = size.encode(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
-      },
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  var getStringDecoder = (options = {}) => {
-    const size = options.size ?? getU32Decoder();
-    const encoding = options.encoding ?? getUtf8Decoder();
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
-    if (size === "variable") {
-      return { ...encoding, description };
-    }
-    if (typeof size === "number") {
-      return fixDecoder(encoding, size, description);
-    }
-    return {
-      decode: (bytes, offset = 0) => {
-        assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
-        const [lengthBigInt, lengthOffset] = size.decode(bytes, offset);
-        const length = Number(lengthBigInt);
-        offset = lengthOffset;
-        const contentBytes = bytes.slice(offset, offset + length);
-        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
-        const [value, contentOffset] = encoding.decode(contentBytes);
-        offset += contentOffset;
-        return [value, offset];
-      },
-      description,
-      fixedSize: null,
-      maxSize: null
-    };
-  };
-  function getSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${size}`;
-  }
-
-  // src/address.ts
-  var memoizedBase58Encoder;
-  var memoizedBase58Decoder;
-  function getMemoizedBase58Encoder() {
-    if (!memoizedBase58Encoder)
-      memoizedBase58Encoder = getBase58Encoder();
-    return memoizedBase58Encoder;
-  }
-  function getMemoizedBase58Decoder() {
-    if (!memoizedBase58Decoder)
-      memoizedBase58Decoder = getBase58Decoder();
-    return memoizedBase58Decoder;
-  }
-  function isAddress(putativeBase58EncodedAddress) {
-    if (
-      // Lowest address (32 bytes of zeroes)
-      putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-      putativeBase58EncodedAddress.length > 44
-    ) {
-      return false;
-    }
-    const base58Encoder = getMemoizedBase58Encoder();
-    const bytes = base58Encoder.encode(putativeBase58EncodedAddress);
-    const numBytes = bytes.byteLength;
-    if (numBytes !== 32) {
-      return false;
-    }
-    return true;
-  }
-  function assertIsAddress(putativeBase58EncodedAddress) {
-    try {
-      if (
-        // Lowest address (32 bytes of zeroes)
-        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-        putativeBase58EncodedAddress.length > 44
-      ) {
-        throw new Error("Expected input string to decode to a byte array of length 32.");
-      }
-      const base58Encoder = getMemoizedBase58Encoder();
-      const bytes = base58Encoder.encode(putativeBase58EncodedAddress);
-      const numBytes = bytes.byteLength;
-      if (numBytes !== 32) {
-        throw new Error(`Expected input string to decode to a byte array of length 32. Actual length: ${numBytes}`);
-      }
-    } catch (e2) {
-      throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-        cause: e2
-      });
-    }
-  }
-  function address(putativeBase58EncodedAddress) {
-    assertIsAddress(putativeBase58EncodedAddress);
-    return putativeBase58EncodedAddress;
-  }
-  function getAddressEncoder(config) {
-    return mapEncoder(
-      getStringEncoder({
-        description: config?.description ?? "Base58EncodedAddress",
-        encoding: getMemoizedBase58Encoder(),
-        size: 32
-      }),
-      (putativeAddress) => address(putativeAddress)
-    );
-  }
-  function getAddressDecoder(config) {
-    return getStringDecoder({
-      description: config?.description ?? "Base58EncodedAddress",
-      encoding: getMemoizedBase58Decoder(),
-      size: 32
-    });
-  }
-  function getAddressCodec(config) {
-    return combineCodec(getAddressEncoder(config), getAddressDecoder(config));
-  }
-  function getAddressComparator() {
-    return new Intl.Collator("en", {
-      caseFirst: "lower",
-      ignorePunctuation: false,
-      localeMatcher: "best fit",
-      numeric: false,
-      sensitivity: "variant",
-      usage: "sort"
-    }).compare;
-  }
-
-  // ../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 assertDigestCapabilityIsAvailable() {
-    assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.digest !== "function") {
-      throw new Error("No digest implementation could be found");
-    }
-  }
-  async function assertKeyExporterIsAvailable() {
-    assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") {
-      throw new Error("No key export implementation could be found");
-    }
-  }
-
-  // src/vendor/noble/ed25519.ts
-  var D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
-  var P = 57896044618658097711785492504343953926634992332820282019728792003956564819949n;
-  var RM1 = 19681161376707505956807079304988542015446066515923890162744021073123829784752n;
-  function mod(a) {
-    const r = a % P;
-    return r >= 0n ? r : P + r;
-  }
-  function pow2(x, power) {
-    let r = x;
-    while (power-- > 0n) {
-      r *= r;
-      r %= P;
-    }
-    return r;
-  }
-  function pow_2_252_3(x) {
-    const x2 = x * x % P;
-    const b2 = x2 * x % P;
-    const b4 = pow2(b2, 2n) * b2 % P;
-    const b5 = pow2(b4, 1n) * x % P;
-    const b10 = pow2(b5, 5n) * b5 % P;
-    const b20 = pow2(b10, 10n) * b10 % P;
-    const b40 = pow2(b20, 20n) * b20 % P;
-    const b80 = pow2(b40, 40n) * b40 % P;
-    const b160 = pow2(b80, 80n) * b80 % P;
-    const b240 = pow2(b160, 80n) * b80 % P;
-    const b250 = pow2(b240, 10n) * b10 % P;
-    const pow_p_5_8 = pow2(b250, 2n) * x % P;
-    return pow_p_5_8;
-  }
-  function uvRatio(u, v) {
-    const v3 = mod(v * v * v);
-    const v7 = mod(v3 * v3 * v);
-    const pow = pow_2_252_3(u * v7);
-    let x = mod(u * v3 * pow);
-    const vx2 = mod(v * x * x);
-    const root1 = x;
-    const root2 = mod(x * RM1);
-    const useRoot1 = vx2 === u;
-    const useRoot2 = vx2 === mod(-u);
-    const noRoot = vx2 === mod(-u * RM1);
-    if (useRoot1)
-      x = root1;
-    if (useRoot2 || noRoot)
-      x = root2;
-    if ((mod(x) & 1n) === 1n)
-      x = mod(-x);
-    if (!useRoot1 && !useRoot2) {
-      return null;
-    }
-    return x;
-  }
-  function pointIsOnCurve(y, lastByte) {
-    const y2 = mod(y * y);
-    const u = mod(y2 - 1n);
-    const v = mod(D * y2 + 1n);
-    const x = uvRatio(u, v);
-    if (x === null) {
-      return false;
-    }
-    const isLastByteOdd = (lastByte & 128) !== 0;
-    if (x === 0n && isLastByteOdd) {
-      return false;
-    }
-    return true;
-  }
-
-  // src/curve.ts
-  function byteToHex(byte) {
-    const hexString = byte.toString(16);
-    if (hexString.length === 1) {
-      return `0${hexString}`;
-    } else {
-      return hexString;
-    }
-  }
-  function decompressPointBytes(bytes) {
-    const hexString = bytes.reduce((acc, byte, ii) => `${byteToHex(ii === 31 ? byte & ~128 : byte)}${acc}`, "");
-    const integerLiteralString = `0x${hexString}`;
-    return BigInt(integerLiteralString);
-  }
-  async function compressedPointBytesAreOnCurve(bytes) {
-    if (bytes.byteLength !== 32) {
-      return false;
-    }
-    const y = decompressPointBytes(bytes);
-    return pointIsOnCurve(y, bytes[31]);
-  }
-
-  // src/program-derived-address.ts
-  function isProgramDerivedAddress(value) {
-    return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number" && value[1] >= 0 && value[1] <= 255 && isAddress(value[0]);
-  }
-  function assertIsProgramDerivedAddress(value) {
-    const validFormat = Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "number";
-    if (!validFormat) {
-      throw new Error(
-        `Expected given program derived address to have the following format: [Base58EncodedAddress, ProgramDerivedAddressBump].`
-      );
-    }
-    if (value[1] < 0 || value[1] > 255) {
-      throw new Error(`Expected program derived address bump to be in the range [0, 255], got: ${value[1]}.`);
-    }
-    assertIsAddress(value[0]);
-  }
-  var MAX_SEED_LENGTH = 32;
-  var MAX_SEEDS = 16;
-  var PDA_MARKER_BYTES = [
-    // The string 'ProgramDerivedAddress'
-    80,
-    114,
-    111,
-    103,
-    114,
-    97,
-    109,
-    68,
-    101,
-    114,
-    105,
-    118,
-    101,
-    100,
-    65,
-    100,
-    100,
-    114,
-    101,
-    115,
-    115
-  ];
-  var PointOnCurveError = class extends Error {
-  };
-  async function createProgramDerivedAddress({
-    programAddress,
-    seeds
-  }) {
-    await assertDigestCapabilityIsAvailable();
-    if (seeds.length > MAX_SEEDS) {
-      throw new Error(`A maximum of ${MAX_SEEDS} seeds may be supplied when creating an address`);
-    }
-    let textEncoder;
-    const seedBytes = seeds.reduce((acc, seed, ii) => {
-      const bytes = typeof seed === "string" ? (textEncoder || (textEncoder = new TextEncoder())).encode(seed) : seed;
-      if (bytes.byteLength > MAX_SEED_LENGTH) {
-        throw new Error(`The seed at index ${ii} exceeds the maximum length of 32 bytes`);
-      }
-      acc.push(...bytes);
-      return acc;
-    }, []);
-    const base58EncodedAddressCodec = getAddressCodec();
-    const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);
-    const addressBytesBuffer = await crypto.subtle.digest(
-      "SHA-256",
-      new Uint8Array([...seedBytes, ...programAddressBytes, ...PDA_MARKER_BYTES])
-    );
-    const addressBytes = new Uint8Array(addressBytesBuffer);
-    if (await compressedPointBytesAreOnCurve(addressBytes)) {
-      throw new PointOnCurveError("Invalid seeds; point must fall off the Ed25519 curve");
-    }
-    return base58EncodedAddressCodec.decode(addressBytes)[0];
-  }
-  async function getProgramDerivedAddress({
-    programAddress,
-    seeds
-  }) {
-    let bumpSeed = 255;
-    while (bumpSeed > 0) {
-      try {
-        const address2 = await createProgramDerivedAddress({
-          programAddress,
-          seeds: [...seeds, new Uint8Array([bumpSeed])]
-        });
-        return [address2, bumpSeed];
-      } catch (e2) {
-        if (e2 instanceof PointOnCurveError) {
-          bumpSeed--;
-        } else {
-          throw e2;
-        }
-      }
-    }
-    throw new Error("Unable to find a viable program address bump seed");
-  }
-  async function createAddressWithSeed({
-    baseAddress,
-    programAddress,
-    seed
-  }) {
-    const { encode, decode } = getAddressCodec();
-    const seedBytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
-    if (seedBytes.byteLength > MAX_SEED_LENGTH) {
-      throw new Error(`The seed exceeds the maximum length of 32 bytes`);
-    }
-    const programAddressBytes = encode(programAddress);
-    if (programAddressBytes.length >= PDA_MARKER_BYTES.length && programAddressBytes.slice(-PDA_MARKER_BYTES.length).every((byte, index) => byte === PDA_MARKER_BYTES[index])) {
-      throw new Error(`programAddress cannot end with the PDA marker`);
-    }
-    const addressBytesBuffer = await crypto.subtle.digest(
-      "SHA-256",
-      new Uint8Array([...encode(baseAddress), ...seedBytes, ...programAddressBytes])
-    );
-    const addressBytes = new Uint8Array(addressBytesBuffer);
-    return decode(addressBytes)[0];
-  }
-
-  // src/public-key.ts
-  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);
-    const [base58EncodedAddress] = getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
-    return base58EncodedAddress;
-  }
-
-  exports.address = address;
-  exports.assertIsAddress = assertIsAddress;
-  exports.assertIsProgramDerivedAddress = assertIsProgramDerivedAddress;
-  exports.createAddressWithSeed = createAddressWithSeed;
-  exports.getAddressCodec = getAddressCodec;
-  exports.getAddressComparator = getAddressComparator;
-  exports.getAddressDecoder = getAddressDecoder;
-  exports.getAddressEncoder = getAddressEncoder;
-  exports.getAddressFromPublicKey = getAddressFromPublicKey;
-  exports.getProgramDerivedAddress = getProgramDerivedAddress;
-  exports.isAddress = isAddress;
-  exports.isProgramDerivedAddress = isProgramDerivedAddress;
-
-  return exports;
-
-})({});
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.development.js.map