@solana/addresses 2.0.0-experimental.fcae73c → 2.0.0-experimental.fcff844

package/dist/index.development.js

@@ -2,24 +2,18 @@ this.globalThis = this.globalThis || {};
 this.globalThis.solanaWeb3 = (function (exports) {
   'use strict';
 
-  var __defProp = Object.defineProperty;
-  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-  var __publicField = (obj, key, value) => {
-    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-    return value;
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/bytes.mjs
-  var mergeBytes = (bytesArr) => {
-    const totalLength = bytesArr.reduce((total, arr) => total + arr.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    bytesArr.forEach((arr) => {
-      result.set(arr, offset);
-      offset += arr.length;
-    });
-    return result;
-  };
+  // ../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;
@@ -27,274 +21,357 @@ this.globalThis.solanaWeb3 = (function (exports) {
     paddedBytes.set(bytes);
     return paddedBytes;
   };
-  var fixBytes = (bytes, length) => padBytes(bytes.slice(0, length), length);
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/errors.mjs
-  var DeserializingEmptyBufferError = class extends Error {
-    constructor(serializer) {
-      super(`Serializer [${serializer}] cannot deserialize empty buffers.`);
-      __publicField(this, "name", "DeserializingEmptyBufferError");
+  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 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.`);
     }
-  };
-  var NotEnoughBytesError = class extends Error {
-    constructor(serializer, expected, actual) {
-      super(`Serializer [${serializer}] expected ${expected} bytes, got ${actual}.`);
-      __publicField(this, "name", "NotEnoughBytesError");
+    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}].`
+      );
     }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-core@0.8.2/node_modules/@metaplex-foundation/umi-serializers-core/dist/esm/fixSerializer.mjs
-  function fixSerializer(serializer, fixedBytes, description) {
     return {
-      description: description ?? `fixed(${fixedBytes}, ${serializer.description})`,
+      ...decoder,
+      ...encoder,
+      decode: decoder.decode,
+      encode: encoder.encode,
+      read: decoder.read,
+      write: encoder.write
+    };
+  }
+  function fixEncoder(encoder, fixedBytes) {
+    return createEncoder({
       fixedSize: fixedBytes,
-      maxSize: fixedBytes,
-      serialize: (value) => fixBytes(serializer.serialize(value), fixedBytes),
-      deserialize: (buffer, offset = 0) => {
-        buffer = buffer.slice(offset, offset + fixedBytes);
-        if (buffer.length < fixedBytes) {
-          throw new NotEnoughBytesError("fixSerializer", fixedBytes, buffer.length);
+      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 (serializer.fixedSize !== null) {
-          buffer = fixBytes(buffer, serializer.fixedSize);
+        if (isFixedSize(decoder)) {
+          bytes = fixBytes(bytes, decoder.fixedSize);
         }
-        const [value] = serializer.deserialize(buffer, 0);
+        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)
+    });
   }
 
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/errors.mjs
-  var InvalidBaseStringError = class extends Error {
-    constructor(value, base, cause) {
-      const message = `Expected a string of base ${base}, got [${value}].`;
-      super(message);
-      __publicField(this, "name", "InvalidBaseStringError");
-      this.cause = cause;
+  // ../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}.`
+      );
     }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/baseX.mjs
-  var baseX = (alphabet) => {
-    const base = alphabet.length;
-    const baseBigInt = BigInt(base);
-    return {
-      description: `base${base}`,
-      fixedSize: null,
-      maxSize: null,
-      serialize(value) {
-        if (!value.match(new RegExp(`^[${alphabet}]*$`))) {
-          throw new InvalidBaseStringError(value, base);
+  }
+  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 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
+  });
+
+  // ../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 new Uint8Array();
-        const chars = [...value];
-        let trailIndex = chars.findIndex((c) => c !== alphabet[0]);
-        trailIndex = trailIndex === -1 ? chars.length : trailIndex;
-        const leadingZeroes = Array(trailIndex).fill(0);
-        if (trailIndex === chars.length)
-          return Uint8Array.from(leadingZeroes);
-        const tailChars = chars.slice(trailIndex);
-        let base10Number = 0n;
-        let baseXPower = 1n;
-        for (let i = tailChars.length - 1; i >= 0; i -= 1) {
-          base10Number += baseXPower * BigInt(alphabet.indexOf(tailChars[i]));
-          baseXPower *= baseBigInt;
+          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;
         }
-        return Uint8Array.from(leadingZeroes.concat(tailBytes));
-      },
-      deserialize(buffer, offset = 0) {
-        if (buffer.length === 0)
+        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];
-        const bytes = buffer.slice(offset);
         let trailIndex = bytes.findIndex((n) => n !== 0);
         trailIndex = trailIndex === -1 ? bytes.length : trailIndex;
-        const leadingZeroes = alphabet[0].repeat(trailIndex);
+        const leadingZeroes = alphabet4[0].repeat(trailIndex);
         if (trailIndex === bytes.length)
-          return [leadingZeroes, buffer.length];
-        let base10Number = bytes.slice(trailIndex).reduce((sum, byte) => sum * 256n + BigInt(byte), 0n);
-        const tailChars = [];
-        while (base10Number > 0n) {
-          tailChars.unshift(alphabet[Number(base10Number % baseBigInt)]);
-          base10Number /= baseBigInt;
-        }
-        return [leadingZeroes + tailChars.join(""), buffer.length];
+          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];
       }
-    };
+    });
   };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/base58.mjs
-  var base58 = baseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/nullCharacters.mjs
+  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, "")
   );
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-encodings@0.8.2/node_modules/@metaplex-foundation/umi-serializers-encodings/dist/esm/utf8.mjs
-  var utf8 = {
-    description: "utf8",
-    fixedSize: null,
-    maxSize: null,
-    serialize(value) {
-      return new TextEncoder().encode(value);
-    },
-    deserialize(buffer, offset = 0) {
-      const value = new TextDecoder().decode(buffer.slice(offset));
-      return [removeNullCharacters(value), buffer.length];
-    }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/common.mjs
-  var Endian;
-  (function(Endian2) {
-    Endian2["Little"] = "le";
-    Endian2["Big"] = "be";
-  })(Endian || (Endian = {}));
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/errors.mjs
-  var NumberOutOfRangeError = class extends RangeError {
-    constructor(serializer, min, max, actual) {
-      super(`Serializer [${serializer}] expected number to be between ${min} and ${max}, got ${actual}.`);
-      __publicField(this, "name", "NumberOutOfRangeError");
-    }
+  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;
+      }
+    });
   };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/utils.mjs
-  function numberFactory(input) {
-    let littleEndian;
-    let defaultDescription = input.name;
-    if (input.size > 1) {
-      littleEndian = !("endian" in input.options) || input.options.endian === Endian.Little;
-      defaultDescription += littleEndian ? "(le)" : "(be)";
-    }
-    return {
-      description: input.options.description ?? defaultDescription,
-      fixedSize: input.size,
-      maxSize: input.size,
-      serialize(value) {
-        if (input.range) {
-          assertRange(input.name, input.range[0], input.range[1], value);
-        }
-        const buffer = new ArrayBuffer(input.size);
-        input.set(new DataView(buffer), value, littleEndian);
-        return new Uint8Array(buffer);
-      },
-      deserialize(bytes, offset = 0) {
-        const slice = bytes.slice(offset, offset + input.size);
-        assertEnoughBytes("i8", slice, input.size);
-        const view = toDataView(slice);
-        return [input.get(view, littleEndian), offset + input.size];
+  var getUtf8Decoder = () => {
+    let textDecoder;
+    return createDecoder({
+      read(bytes, offset) {
+        const value = (textDecoder || (textDecoder = new e())).decode(bytes.slice(offset));
+        return [removeNullCharacters(value), bytes.length];
       }
-    };
-  }
-  var toArrayBuffer = (array) => array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);
-  var toDataView = (array) => new DataView(toArrayBuffer(array));
-  var assertRange = (serializer, min, max, value) => {
-    if (value < min || value > max) {
-      throw new NumberOutOfRangeError(serializer, min, max, value);
-    }
+    });
   };
-  var assertEnoughBytes = (serializer, bytes, expected) => {
-    if (bytes.length === 0) {
-      throw new DeserializingEmptyBufferError(serializer);
+  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 (bytes.length < expected) {
-      throw new NotEnoughBytesError(serializer, expected, bytes.length);
+    if (typeof size === "number") {
+      return fixEncoder(encoding, size);
     }
-  };
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers-numbers@0.8.2/node_modules/@metaplex-foundation/umi-serializers-numbers/dist/esm/u32.mjs
-  var u32 = (options = {}) => numberFactory({
-    name: "u32",
-    size: 4,
-    range: [0, Number("0xffffffff")],
-    set: (view, value, le) => view.setUint32(0, Number(value), le),
-    get: (view, le) => view.getUint32(0, le),
-    options
-  });
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/utils.mjs
-  function getSizeDescription(size) {
-    return typeof size === "object" ? size.description : `${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);
+      }
+    });
   }
-
-  // ../../node_modules/.pnpm/@metaplex-foundation+umi-serializers@0.8.5/node_modules/@metaplex-foundation/umi-serializers/dist/esm/string.mjs
-  function string(options = {}) {
-    const size = options.size ?? u32();
-    const encoding = options.encoding ?? utf8;
-    const description = options.description ?? `string(${encoding.description}; ${getSizeDescription(size)})`;
+  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,
-        description
-      };
+      return encoding;
     }
     if (typeof size === "number") {
-      return fixSerializer(encoding, size, description);
+      return fixDecoder(encoding, size);
     }
-    return {
-      description,
-      fixedSize: null,
-      maxSize: null,
-      serialize: (value) => {
-        const contentBytes = encoding.serialize(value);
-        const lengthBytes = size.serialize(contentBytes.length);
-        return mergeBytes([lengthBytes, contentBytes]);
-      },
-      deserialize: (buffer, offset = 0) => {
-        if (buffer.slice(offset).length === 0) {
-          throw new DeserializingEmptyBufferError("string");
-        }
-        const [lengthBigInt, lengthOffset] = size.deserialize(buffer, offset);
+    return createDecoder({
+      read: (bytes, offset = 0) => {
+        assertByteArrayIsNotEmptyForCodec("string", bytes, offset);
+        const [lengthBigInt, lengthOffset] = size.read(bytes, offset);
         const length = Number(lengthBigInt);
         offset = lengthOffset;
-        const contentBuffer = buffer.slice(offset, offset + length);
-        if (contentBuffer.length < length) {
-          throw new NotEnoughBytesError("string", length, contentBuffer.length);
-        }
-        const [value, contentOffset] = encoding.deserialize(contentBuffer);
+        const contentBytes = bytes.slice(offset, offset + length);
+        assertByteArrayHasEnoughBytesForCodec("string", length, contentBytes);
+        const [value, contentOffset] = encoding.read(contentBytes, 0);
         offset += contentOffset;
         return [value, offset];
       }
-    };
+    });
   }
 
-  // src/base58.ts
-  function assertIsBase58EncodedAddress(putativeBase58EncodedAddress) {
+  // 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(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)
-        putativeBase58EncodedAddress.length < 32 || // Highest address (32 bytes of 255)
-        putativeBase58EncodedAddress.length > 44
+        putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+        putativeAddress.length > 44
       ) {
         throw new Error("Expected input string to decode to a byte array of length 32.");
       }
-      const bytes = base58.serialize(putativeBase58EncodedAddress);
+      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 (e) {
-      throw new Error(`\`${putativeBase58EncodedAddress}\` is not a base-58 encoded address`, {
-        cause: e
+    } catch (e2) {
+      throw new Error(`\`${putativeAddress}\` is not a base-58 encoded address`, {
+        cause: e2
       });
     }
   }
-  function getBase58EncodedAddressCodec(config) {
-    return string({
-      description: config?.description ?? ("A 32-byte account address" ),
-      encoding: base58,
-      size: 32
-    });
+  function address(putativeAddress) {
+    assertIsAddress(putativeAddress);
+    return putativeAddress;
   }
-  function getBase58EncodedAddressComparator() {
+  function getAddressEncoder() {
+    return mapEncoder(
+      getStringEncoder({ encoding: getMemoizedBase58Encoder(), size: 32 }),
+      (putativeAddress) => address(putativeAddress)
+    );
+  }
+  function getAddressDecoder() {
+    return getStringDecoder({ encoding: getMemoizedBase58Decoder(), size: 32 });
+  }
+  function getAddressCodec() {
+    return combineCodec(getAddressEncoder(), getAddressDecoder());
+  }
+  function getAddressComparator() {
     return new Intl.Collator("en", {
       caseFirst: "lower",
       ignorePunctuation: false,
@@ -314,14 +391,16 @@ this.globalThis.solanaWeb3 = (function (exports) {
     }
   }
   async function assertDigestCapabilityIsAvailable() {
+    var _a;
     assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.digest !== "function") {
+    if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.digest) !== "function") {
       throw new Error("No digest implementation could be found");
     }
   }
   async function assertKeyExporterIsAvailable() {
+    var _a;
     assertIsSecureContext();
-    if (typeof globalThis.crypto === "undefined" || typeof globalThis.crypto.subtle?.exportKey !== "function") {
+    if (typeof globalThis.crypto === "undefined" || typeof ((_a = globalThis.crypto.subtle) == null ? void 0 : _a.exportKey) !== "function") {
       throw new Error("No key export implementation could be found");
     }
   }
@@ -417,6 +496,21 @@ this.globalThis.solanaWeb3 = (function (exports) {
   }
 
   // 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: [Address, 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 = [
@@ -459,8 +553,8 @@ this.globalThis.solanaWeb3 = (function (exports) {
       acc.push(...bytes);
       return acc;
     }, []);
-    const base58EncodedAddressCodec = getBase58EncodedAddressCodec();
-    const programAddressBytes = base58EncodedAddressCodec.serialize(programAddress);
+    const base58EncodedAddressCodec = getAddressCodec();
+    const programAddressBytes = base58EncodedAddressCodec.encode(programAddress);
     const addressBytesBuffer = await crypto.subtle.digest(
       "SHA-256",
       new Uint8Array([...seedBytes, ...programAddressBytes, ...PDA_MARKER_BYTES])
@@ -469,46 +563,70 @@ this.globalThis.solanaWeb3 = (function (exports) {
     if (await compressedPointBytesAreOnCurve(addressBytes)) {
       throw new PointOnCurveError("Invalid seeds; point must fall off the Ed25519 curve");
     }
-    return base58EncodedAddressCodec.deserialize(addressBytes)[0];
+    return base58EncodedAddressCodec.decode(addressBytes);
   }
-  async function getProgramDerivedAddress({ programAddress, seeds }) {
+  async function getProgramDerivedAddress({
+    programAddress,
+    seeds
+  }) {
     let bumpSeed = 255;
     while (bumpSeed > 0) {
       try {
-        return {
-          bumpSeed,
-          pda: await createProgramDerivedAddress({
-            programAddress,
-            seeds: [...seeds, new Uint8Array([bumpSeed])]
-          })
-        };
-      } catch (e) {
-        if (e instanceof PointOnCurveError) {
+        const address2 = await createProgramDerivedAddress({
+          programAddress,
+          seeds: [...seeds, new Uint8Array([bumpSeed])]
+        });
+        return [address2, bumpSeed];
+      } catch (e2) {
+        if (e2 instanceof PointOnCurveError) {
           bumpSeed--;
         } else {
-          throw e;
+          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);
+  }
 
   // src/public-key.ts
-  async function getBase58EncodedAddressFromPublicKey(publicKey) {
+  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] = getBase58EncodedAddressCodec().deserialize(new Uint8Array(publicKeyBytes));
-    return base58EncodedAddress;
+    return getAddressDecoder().decode(new Uint8Array(publicKeyBytes));
   }
 
-  exports.assertIsBase58EncodedAddress = assertIsBase58EncodedAddress;
-  exports.getBase58EncodedAddressCodec = getBase58EncodedAddressCodec;
-  exports.getBase58EncodedAddressComparator = getBase58EncodedAddressComparator;
-  exports.getBase58EncodedAddressFromPublicKey = getBase58EncodedAddressFromPublicKey;
+  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;