@talismn/crypto 0.3.5 → 1.0.0

package/dist/index.js

@@ -1,816 +1,877 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DEV_MNEMONIC_ETHEREUM: () => DEV_MNEMONIC_ETHEREUM,
-  DEV_MNEMONIC_POLKADOT: () => DEV_MNEMONIC_POLKADOT,
-  addressEncodingFromCurve: () => addressEncodingFromCurve,
-  addressFromMnemonic: () => addressFromMnemonic,
-  addressFromPublicKey: () => addressFromPublicKey,
-  base58: () => import_base4.base58,
-  base64: () => import_base4.base64,
-  blake2b256: () => blake2b256,
-  blake2b512: () => blake2b512,
-  blake3: () => blake3,
-  checksumEthereumAddress: () => checksumEthereumAddress,
-  decodeSs58Address: () => decodeSs58Address,
-  deriveKeypair: () => deriveKeypair,
-  detectAddressEncoding: () => detectAddressEncoding,
-  ed25519: () => import_ed255192.ed25519,
-  encodeAddressEthereum: () => encodeAddressEthereum,
-  encodeAddressSolana: () => encodeAddressSolana,
-  encodeAddressSs58: () => encodeAddressSs58,
-  encodeAnyAddress: () => encodeAnyAddress,
-  encryptKemAead: () => encryptKemAead,
-  entropyToMnemonic: () => entropyToMnemonic,
-  entropyToSeed: () => entropyToSeed,
-  fromBase58Check: () => fromBase58Check,
-  fromBech32: () => fromBech32,
-  fromBech32m: () => fromBech32m,
-  generateMnemonic: () => generateMnemonic,
-  getAccountPlatformFromAddress: () => getAccountPlatformFromAddress,
-  getAccountPlatformFromCurve: () => getAccountPlatformFromCurve,
-  getAccountPlatformFromEncoding: () => getAccountPlatformFromEncoding,
-  getDevSeed: () => getDevSeed,
-  getPublicKeyFromSecret: () => getPublicKeyFromSecret,
-  getPublicKeySolana: () => getPublicKeySolana,
-  getSafeHash: () => getSafeHash,
-  hex: () => import_base4.hex,
-  isAddressEqual: () => isAddressEqual,
-  isAddressValid: () => isAddressValid,
-  isBase58CheckAddress: () => isBase58CheckAddress,
-  isBech32Address: () => isBech32Address,
-  isBech32mAddress: () => isBech32mAddress,
-  isBitcoinAddress: () => isBitcoinAddress,
-  isEthereumAddress: () => isEthereumAddress,
-  isSolanaAddress: () => isSolanaAddress,
-  isSs58Address: () => isSs58Address,
-  isValidDerivationPath: () => isValidDerivationPath,
-  isValidMnemonic: () => isValidMnemonic,
-  mnemonicToEntropy: () => mnemonicToEntropy,
-  normalizeAddress: () => normalizeAddress,
-  parseSecretKey: () => parseSecretKey,
-  pbkdf2: () => pbkdf2,
-  removeHexPrefix: () => removeHexPrefix,
-  utf8: () => import_base4.utf8
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/address/encoding/addressEncodingFromCurve.ts
-var addressEncodingFromCurve = (curve) => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "ss58";
-    case "bitcoin-ecdsa":
-    case "bitcoin-ed25519":
-      return "bech32m";
-    case "ethereum":
-      return "ethereum";
-    case "solana":
-      return "base58solana";
-  }
-};
-
-// src/address/encoding/bitcoin.ts
-var import_bech32 = require("bech32");
-var import_bs58check = __toESM(require("bs58check"));
-var isBitcoinAddress = (address) => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let bech32 = require("bech32");
+let bs58check = require("bs58check");
+bs58check = __toESM(bs58check);
+let _noble_curves_secp256k1_js = require("@noble/curves/secp256k1.js");
+let _noble_hashes_sha3_js = require("@noble/hashes/sha3.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _noble_curves_ed25519_js = require("@noble/curves/ed25519.js");
+let _scure_base = require("@scure/base");
+let _noble_hashes_blake2_js = require("@noble/hashes/blake2.js");
+let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
+let _noble_hashes_hmac_js = require("@noble/hashes/hmac.js");
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _scure_bip39 = require("@scure/bip39");
+let _scure_bip39_wordlists_english_js = require("@scure/bip39/wordlists/english.js");
+let scale_ts = require("scale-ts");
+let _scure_bip32 = require("@scure/bip32");
+let _scure_sr25519 = require("@scure/sr25519");
+let _noble_ciphers_chacha_js = require("@noble/ciphers/chacha.js");
+let _noble_ciphers_utils_js = require("@noble/ciphers/utils.js");
+let mlkem = require("mlkem");
+let _noble_ciphers_salsa_js = require("@noble/ciphers/salsa.js");
+let _noble_hashes_scrypt_js = require("@noble/hashes/scrypt.js");
+//#region src/address/encoding/addressEncodingFromCurve.ts
+/** NOTE: Try not to use this too much, it will need to change */
+const addressEncodingFromCurve = (curve) => {
+	switch (curve) {
+		case "sr25519":
+		case "ed25519":
+		case "ecdsa": return "ss58";
+		case "bitcoin-ecdsa":
+		case "bitcoin-ed25519": return "bech32m";
+		case "ethereum": return "ethereum";
+		case "solana": return "base58solana";
+	}
+};
+//#endregion
+//#region src/address/encoding/bitcoin.ts
+const isBitcoinAddress = (address) => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
 function isBech32mAddress(address) {
-  try {
-    fromBech32m(address);
-  } catch {
-    return false;
-  }
-  return true;
+	try {
+		fromBech32m(address);
+	} catch {
+		return false;
+	}
+	return true;
 }
 function isBech32Address(address) {
-  try {
-    fromBech32(address);
-  } catch {
-    return false;
-  }
-  return true;
+	try {
+		fromBech32(address);
+	} catch {
+		return false;
+	}
+	return true;
 }
 function isBase58CheckAddress(address) {
-  try {
-    fromBase58Check(address);
-  } catch {
-    return false;
-  }
-  return true;
+	try {
+		fromBase58Check(address);
+	} catch {
+		return false;
+	}
+	return true;
 }
+/**
+* Converts a Bech32m encoded address to its corresponding data representation.
+* @param address - The Bech32m encoded address.
+* @returns An object containing the version, prefix, and data of the address.
+* @throws {TypeError} If the address uses the wrong encoding.
+*/
 function fromBech32m(address) {
-  const result = import_bech32.bech32m.decode(address);
-  const version = result.words[0];
-  if (version === 0) throw new TypeError(`${address} uses wrong encoding`);
-  const data = import_bech32.bech32m.fromWords(result.words.slice(1));
-  return {
-    version,
-    prefix: result.prefix,
-    data: Uint8Array.from(data)
-  };
+	const result = bech32.bech32m.decode(address);
+	const version = result.words[0];
+	if (version === 0) throw new TypeError(`${address} uses wrong encoding`);
+	const data = bech32.bech32m.fromWords(result.words.slice(1));
+	return {
+		version,
+		prefix: result.prefix,
+		data: Uint8Array.from(data)
+	};
 }
+/**
+* Converts a Bech32 encoded address to its corresponding data representation.
+* @param address - The Bech32 encoded address.
+* @returns An object containing the version, prefix, and data of the address.
+* @throws {TypeError} If the address uses the wrong encoding.
+*/
 function fromBech32(address) {
-  const result = import_bech32.bech32.decode(address);
-  const version = result.words[0];
-  if (version !== 0) throw new TypeError(`${address} uses wrong encoding`);
-  const data = import_bech32.bech32.fromWords(result.words.slice(1));
-  return {
-    version,
-    prefix: result.prefix,
-    data: Uint8Array.from(data)
-  };
+	const result = bech32.bech32.decode(address);
+	const version = result.words[0];
+	if (version !== 0) throw new TypeError(`${address} uses wrong encoding`);
+	const data = bech32.bech32.fromWords(result.words.slice(1));
+	return {
+		version,
+		prefix: result.prefix,
+		data: Uint8Array.from(data)
+	};
 }
+/**
+* Decodes a base58check encoded Bitcoin address and returns the version and hash.
+*
+* @param address - The base58check encoded Bitcoin address to decode.
+* @returns An object containing the version and hash of the decoded address.
+* @throws {TypeError} If the address is too short or too long.
+*/
 function fromBase58Check(address) {
-  const payload = import_bs58check.default.decode(address);
-  if (payload.length < 21) throw new TypeError(`${address} is too short`);
-  if (payload.length > 21) throw new TypeError(`${address} is too long`);
-  function readUInt8(buffer, offset) {
-    if (offset + 1 > buffer.length) {
-      throw new Error("Offset is outside the bounds of Uint8Array");
-    }
-    return buffer[offset];
-  }
-  const version = readUInt8(payload, 0);
-  const hash = payload.slice(1);
-  return { version, hash };
+	const payload = bs58check.default.decode(address);
+	if (payload.length < 21) throw new TypeError(`${address} is too short`);
+	if (payload.length > 21) throw new TypeError(`${address} is too long`);
+	function readUInt8(buffer, offset) {
+		if (offset + 1 > buffer.length) throw new Error("Offset is outside the bounds of Uint8Array");
+		return buffer[offset];
+	}
+	return {
+		version: readUInt8(payload, 0),
+		hash: payload.slice(1)
+	};
 }
-
-// src/address/encoding/ethereum.ts
-var import_sha3 = require("@noble/hashes/sha3.js");
-var import_utils = require("@noble/hashes/utils.js");
-var encodeAddressEthereum = (publicKey) => {
-  if (publicKey[0] !== 4) throw new Error("Invalid public key format");
-  const publicKeyWithoutPrefix = publicKey.slice(1);
-  const hash = (0, import_sha3.keccak_256)(publicKeyWithoutPrefix);
-  const address = hash.slice(-20);
-  return checksumEthereumAddress(`0x${(0, import_utils.bytesToHex)(address)}`);
-};
-var checksumEthereumAddress = (address) => {
-  const addr = address.toLowerCase().replace(/^0x/, "");
-  const hash = (0, import_sha3.keccak_256)(new TextEncoder().encode(addr));
-  const hashHex = (0, import_utils.bytesToHex)(hash);
-  const checksum = addr.split("").map((char, i) => parseInt(hashHex[i], 16) >= 8 ? char.toUpperCase() : char).join("");
-  return `0x${checksum}`;
+//#endregion
+//#region src/address/encoding/ethereum.ts
+/**
+* Encodes a public key using H160 encoding with Ethereum checksum.
+* Accepts both uncompressed (65 bytes) and compressed (33 bytes) public keys -
+* polkadot-js keystores store the compressed form as the account address.
+*/
+const encodeAddressEthereum = (publicKey) => {
+	if (publicKey.length === 33 && (publicKey[0] === 2 || publicKey[0] === 3)) publicKey = _noble_curves_secp256k1_js.secp256k1.Point.fromBytes(publicKey).toBytes(false);
+	if (publicKey[0] !== 4) throw new Error("Invalid public key format");
+	const address = (0, _noble_hashes_sha3_js.keccak_256)(publicKey.slice(1)).slice(-20);
+	return checksumEthereumAddress(`0x${(0, _noble_hashes_utils_js.bytesToHex)(address)}`);
+};
+const checksumEthereumAddress = (address) => {
+	const addr = address.toLowerCase().replace(/^0x/, "");
+	const hashHex = (0, _noble_hashes_utils_js.bytesToHex)((0, _noble_hashes_sha3_js.keccak_256)(new TextEncoder().encode(addr)));
+	return `0x${addr.split("").map((char, i) => parseInt(hashHex[i], 16) >= 8 ? char.toUpperCase() : char).join("")}`;
 };
 function isEthereumAddress(address) {
-  return /^0x[a-fA-F0-9]{40}$/.test(address);
+	return /^0x[a-fA-F0-9]{40}$/.test(address);
 }
-
-// src/address/encoding/solana.ts
-var import_base = require("@scure/base");
-var encodeAddressSolana = (publicKey) => {
-  if (publicKey.length !== 32)
-    throw new Error("Public key must be 32 bytes long for Solana base58 encoding");
-  return import_base.base58.encode(publicKey);
+//#endregion
+//#region src/address/encoding/solana.ts
+const encodeAddressSolana = (publicKey) => {
+	if (publicKey.length !== 32) throw new Error("Public key must be 32 bytes long for Solana base58 encoding");
+	return _scure_base.base58.encode(publicKey);
 };
 function isSolanaAddress(address) {
-  try {
-    const bytes = import_base.base58.decode(address);
-    return bytes.length === 32;
-  } catch {
-    return false;
-  }
+	try {
+		return _scure_base.base58.decode(address).length === 32;
+	} catch {
+		return false;
+	}
 }
-
-// src/address/encoding/ss58.ts
-var import_base3 = require("@scure/base");
-
-// src/hashing/index.ts
-var import_blake2 = require("@noble/hashes/blake2.js");
-var import_blake3 = require("@noble/hashes/blake3.js");
-var import_base2 = require("@scure/base");
-var blake3 = import_blake3.blake3;
-var blake2b256 = (msg) => (0, import_blake2.blake2b)(msg, { dkLen: 32 });
-var blake2b512 = (msg) => (0, import_blake2.blake2b)(msg, { dkLen: 64 });
-var getSafeHash = (bytes) => {
-  return import_base2.base58.encode((0, import_blake3.blake3)(bytes));
-};
-
-// src/address/encoding/ss58.ts
-var VALID_PUBLICKEY_LENGTHS = [32, 33];
-var accountId = (publicKey) => {
-  if (!VALID_PUBLICKEY_LENGTHS.includes(publicKey.length)) throw new Error("Invalid publicKey");
-  return publicKey.length === 33 ? blake2b256(publicKey) : publicKey;
-};
-var SS58PRE = /* @__PURE__ */ new TextEncoder().encode("SS58PRE");
-var CHECKSUM_LENGTH = 2;
-var VALID_PAYLOAD_LENGTHS = [32, 33];
-var ss58Encode = (payload, prefix = 42) => {
-  if (!VALID_PAYLOAD_LENGTHS.includes(payload.length)) throw new Error("Invalid payload");
-  const prefixBytes = prefix < 64 ? Uint8Array.of(prefix) : Uint8Array.of(
-    (prefix & 252) >> 2 | 64,
-    prefix >> 8 | (prefix & 3) << 6
-  );
-  const checksum = blake2b512(Uint8Array.of(...SS58PRE, ...prefixBytes, ...payload)).subarray(
-    0,
-    CHECKSUM_LENGTH
-  );
-  return import_base3.base58.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
-};
-var VALID_ADDRESS_LENGTHS = [35, 36, 37];
-var decodeSs58Address = (addressStr) => {
-  const address = import_base3.base58.decode(addressStr);
-  if (!VALID_ADDRESS_LENGTHS.includes(address.length)) throw new Error("Invalid address length");
-  const addressChecksum = address.subarray(address.length - CHECKSUM_LENGTH);
-  const checksum = blake2b512(
-    Uint8Array.of(...SS58PRE, ...address.subarray(0, address.length - CHECKSUM_LENGTH))
-  ).subarray(0, CHECKSUM_LENGTH);
-  if (addressChecksum[0] !== checksum[0] || addressChecksum[1] !== checksum[1])
-    throw new Error("Invalid checksum");
-  const prefixLength = address[0] & 64 ? 2 : 1;
-  const prefix = prefixLength === 1 ? address[0] : (address[0] & 63) << 2 | address[1] >> 6 | (address[1] & 63) << 8;
-  const publicKey = address.slice(prefixLength, address.length - CHECKSUM_LENGTH);
-  return [publicKey, prefix];
-};
-var encodeAddressSs58 = (publicKey, prefix = 42) => {
-  if (typeof publicKey === "string") [publicKey] = decodeSs58Address(publicKey);
-  return ss58Encode(accountId(publicKey), prefix);
+/**
+* Whether the address is a valid ed25519 public key (on-curve).
+*
+* Program-derived addresses (PDAs) are off-curve by construction: no private key can exist
+* for them, so a regular wallet cannot recover tokens sent to an account they own.
+*/
+function isOnCurveSolanaAddress(address) {
+	try {
+		_noble_curves_ed25519_js.ed25519.Point.fromBytes(_scure_base.base58.decode(address));
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/hashing/index.ts
+const blake3 = _noble_hashes_blake3_js.blake3;
+const blake2b256 = (msg) => (0, _noble_hashes_blake2_js.blake2b)(msg, { dkLen: 32 });
+const blake2b512 = (msg) => (0, _noble_hashes_blake2_js.blake2b)(msg, { dkLen: 64 });
+const getSafeHash = (bytes) => {
+	return _scure_base.base58.encode((0, _noble_hashes_blake3_js.blake3)(bytes));
+};
+//#endregion
+//#region src/address/encoding/ss58.ts
+const VALID_PUBLICKEY_LENGTHS = [32, 33];
+const accountId = (publicKey) => {
+	if (!VALID_PUBLICKEY_LENGTHS.includes(publicKey.length)) throw new Error("Invalid publicKey");
+	return publicKey.length === 33 ? blake2b256(publicKey) : publicKey;
+};
+const SS58PRE = /* @__PURE__ */ new TextEncoder().encode("SS58PRE");
+const CHECKSUM_LENGTH = 2;
+const VALID_PAYLOAD_LENGTHS = [32, 33];
+const ss58Encode = (payload, prefix = 42) => {
+	if (!VALID_PAYLOAD_LENGTHS.includes(payload.length)) throw new Error("Invalid payload");
+	const prefixBytes = prefix < 64 ? Uint8Array.of(prefix) : Uint8Array.of((prefix & 252) >> 2 | 64, prefix >> 8 | (prefix & 3) << 6);
+	const checksum = blake2b512(Uint8Array.of(...SS58PRE, ...prefixBytes, ...payload)).subarray(0, CHECKSUM_LENGTH);
+	return _scure_base.base58.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
+};
+const VALID_ADDRESS_LENGTHS = [
+	35,
+	36,
+	37
+];
+const decodeSs58Address = (addressStr, ignoreChecksum = false) => {
+	const address = _scure_base.base58.decode(addressStr);
+	if (!VALID_ADDRESS_LENGTHS.includes(address.length)) throw new Error("Invalid address length");
+	const addressChecksum = address.subarray(address.length - CHECKSUM_LENGTH);
+	const checksum = blake2b512(Uint8Array.of(...SS58PRE, ...address.subarray(0, address.length - CHECKSUM_LENGTH))).subarray(0, CHECKSUM_LENGTH);
+	if (!ignoreChecksum && (addressChecksum[0] !== checksum[0] || addressChecksum[1] !== checksum[1])) throw new Error("Invalid checksum");
+	const prefixLength = address[0] & 64 ? 2 : 1;
+	const prefix = prefixLength === 1 ? address[0] : (address[0] & 63) << 2 | address[1] >> 6 | (address[1] & 63) << 8;
+	return [address.slice(prefixLength, address.length - CHECKSUM_LENGTH), prefix];
+};
+const encodeAddressSs58 = (publicKey, prefix = 42) => {
+	if (typeof publicKey === "string") [publicKey] = decodeSs58Address(publicKey);
+	return ss58Encode(accountId(publicKey), prefix);
 };
 function isSs58Address(address) {
-  try {
-    decodeSs58Address(address);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		decodeSs58Address(address);
+		return true;
+	} catch {
+		return false;
+	}
 }
-
-// src/address/encoding/detectAddressEncoding.ts
-var CACHE = /* @__PURE__ */ new Map();
-var detectAddressEncodingInner = (address) => {
-  if (isEthereumAddress(address)) return "ethereum";
-  if (isSs58Address(address)) return "ss58";
-  if (isSolanaAddress(address)) return "base58solana";
-  if (isBech32mAddress(address)) return "bech32m";
-  if (isBech32Address(address)) return "bech32";
-  if (isBase58CheckAddress(address)) return "base58check";
-  throw new Error(`Unknown address encoding`);
-};
-var detectAddressEncoding = (address) => {
-  if (!CACHE.has(address)) CACHE.set(address, detectAddressEncodingInner(address));
-  return CACHE.get(address);
-};
-
-// src/address/addressFromPublicKey.ts
-var addressFromPublicKey = (publicKey, encoding, options) => {
-  switch (encoding) {
-    case "ss58":
-      return encodeAddressSs58(publicKey, options?.ss58Prefix);
-    case "ethereum":
-      return encodeAddressEthereum(publicKey);
-    case "base58solana":
-      return encodeAddressSolana(publicKey);
-    case "bech32m":
-    case "bech32":
-    case "base58check":
-      throw new Error("addressFromPublicKey is not implemented for Bitcoin");
-  }
-};
-
-// src/address/normalizeAddress.ts
-var CACHE2 = /* @__PURE__ */ new Map();
-var normalizeAddress = (address) => {
-  try {
-    if (!CACHE2.has(address)) CACHE2.set(address, normalizeAnyAddress(address));
-    return CACHE2.get(address);
-  } catch (cause) {
-    throw new Error(`Unable to normalize address: ${address}`, { cause });
-  }
-};
-var normalizeAnyAddress = (address) => {
-  switch (detectAddressEncoding(address)) {
-    case "ethereum":
-      return checksumEthereumAddress(address);
-    case "bech32m":
-    case "bech32":
-    case "base58check":
-    case "base58solana":
-      return address;
-    case "ss58": {
-      const [pk] = decodeSs58Address(address);
-      return encodeAddressSs58(pk, 42);
-    }
-  }
-};
-
-// src/address/encodeAnyAddress.ts
-var encodeAnyAddress = (address, options) => {
-  const encoding = detectAddressEncoding(address);
-  if (encoding === "ss58" && options?.ss58Format !== void 0) {
-    const [publicKey] = decodeSs58Address(address);
-    return encodeAddressSs58(publicKey, options?.ss58Format ?? 42);
-  }
-  return normalizeAddress(address);
-};
-
-// src/address/isAddressEqual.ts
-var isAddressEqual = (address1, address2) => {
-  try {
-    return normalizeAddress(address1) === normalizeAddress(address2);
-  } catch {
-    return false;
-  }
-};
-
-// src/address/isAddressValid.ts
-var isAddressValid = (address) => {
-  try {
-    detectAddressEncoding(address);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/derivation/deriveSolana.ts
-var import_ed25519 = require("@noble/curves/ed25519.js");
-var import_hmac = require("@noble/hashes/hmac.js");
-var import_sha2 = require("@noble/hashes/sha2.js");
-var parseDerivationPath = (path) => {
-  if (!path.startsWith("m/")) throw new Error("Path must start with 'm/'");
-  return path.split("/").slice(1).map((p) => {
-    if (!p.endsWith("'")) throw new Error("Only hardened derivation is supported");
-    return parseInt(p.slice(0, -1), 10) + 2147483648;
-  });
-};
-var deriveSolana = (seed, derivationPath) => {
-  let I = (0, import_hmac.hmac)(import_sha2.sha512, new TextEncoder().encode("ed25519 seed"), seed);
-  let secretKey = I.slice(0, 32);
-  let chainCode = I.slice(32);
-  for (const index of parseDerivationPath(derivationPath)) {
-    const data = new Uint8Array(1 + secretKey.length + 4);
-    data.set([0], 0);
-    data.set(secretKey, 1);
-    data.set(
-      new Uint8Array([
-        index >> 24 & 255,
-        index >> 16 & 255,
-        index >> 8 & 255,
-        index & 255
-      ]),
-      1 + secretKey.length
-    );
-    I = (0, import_hmac.hmac)(import_sha2.sha512, chainCode, data);
-    secretKey = I.slice(0, 32);
-    chainCode = I.slice(32);
-  }
-  const publicKey = getPublicKeySolana(secretKey);
-  return {
-    type: "solana",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "base58solana")
-  };
-};
-var getPublicKeySolana = (secretKey) => {
-  return import_ed25519.ed25519.getPublicKey(secretKey);
-};
-
-// src/derivation/utils.ts
-var import_base5 = require("@scure/base");
-
-// src/mnemonic/index.ts
-var import_bip39 = require("@scure/bip39");
-var import_english = require("@scure/bip39/wordlists/english.js");
-
-// src/utils/exports.ts
-var import_ed255192 = require("@noble/curves/ed25519.js");
-var import_base4 = require("@scure/base");
-
-// src/utils/pbkdf2.ts
-var pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
-  const keyMaterial = await crypto.subtle.importKey(
-    "raw",
-    entropy,
-    "PBKDF2",
-    false,
-    ["deriveBits"]
-  );
-  const derivedBits = await crypto.subtle.deriveBits(
-    { name: "PBKDF2", salt, iterations, hash },
-    keyMaterial,
-    outputLenBytes * 8
-  );
-  return new Uint8Array(derivedBits);
-};
-
-// src/mnemonic/index.ts
-var mnemonicToEntropy = (mnemonic) => {
-  return (0, import_bip39.mnemonicToEntropy)(mnemonic, import_english.wordlist);
-};
-var entropyToMnemonic = (entropy) => {
-  return (0, import_bip39.entropyToMnemonic)(entropy, import_english.wordlist);
-};
-var entropyToSeedSubstrate = async (entropy, password) => await pbkdf2(
-  "SHA-512",
-  entropy,
-  mnemonicPasswordToSalt(password ?? ""),
-  2048,
-  // 2048 iterations
-  32
-  // 32 bytes (32 * 8 == 256 bits)
-);
-var entropyToSeedClassic = async (entropy, password) => await pbkdf2(
-  "SHA-512",
-  encodeNormalized(entropyToMnemonic(entropy)),
-  mnemonicPasswordToSalt(password ?? ""),
-  2048,
-  // 2048 iterations
-  64
-  // 64 bytes (64 * 8 == 512 bits)
-);
-var mnemonicPasswordToSalt = (password) => encodeNormalized(`mnemonic${password}`);
-var encodeNormalized = (utf82) => new TextEncoder().encode(utf82.normalize("NFKD"));
-var getSeedDerivationType = (curve) => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "substrate";
-    case "ethereum":
-    case "solana":
-      return "classic";
-    case "bitcoin-ecdsa":
-    case "bitcoin-ed25519":
-      throw new Error("seed derivation is not implemented for Bitcoin");
-  }
-};
-var entropyToSeed = async (entropy, curve, password) => {
-  const type = getSeedDerivationType(curve);
-  switch (type) {
-    case "classic":
-      return await entropyToSeedClassic(entropy, password);
-    case "substrate":
-      return await entropyToSeedSubstrate(entropy, password);
-  }
-};
-var isValidMnemonic = (mnemonic) => {
-  return (0, import_bip39.validateMnemonic)(mnemonic, import_english.wordlist);
-};
-var generateMnemonic = (words) => {
-  switch (words) {
-    case 12:
-      return (0, import_bip39.generateMnemonic)(import_english.wordlist, 128);
-    case 24:
-      return (0, import_bip39.generateMnemonic)(import_english.wordlist, 256);
-  }
-};
-var DEV_MNEMONIC_POLKADOT = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-var DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test test junk";
-var DEV_SEED_CACHE = /* @__PURE__ */ new Map();
-var getDevSeed = async (curve) => {
-  const type = getSeedDerivationType(curve);
-  if (!DEV_SEED_CACHE.has(type)) {
-    switch (type) {
-      case "classic": {
-        const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM);
-        const seed = await entropyToSeedClassic(entropy);
-        DEV_SEED_CACHE.set(type, seed);
-        break;
-      }
-      case "substrate": {
-        const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
-        const seed = await entropyToSeedSubstrate(entropy);
-        DEV_SEED_CACHE.set(type, seed);
-        break;
-      }
-      default:
-        throw new Error("Unsupported derivation type");
-    }
-  }
-  return DEV_SEED_CACHE.get(type);
-};
-
-// src/derivation/deriveEcdsa.ts
-var import_secp256k1 = require("@noble/curves/secp256k1.js");
-
-// src/derivation/common.ts
-var import_scale_ts = require("scale-ts");
-var DERIVATION_RE = /(\/{1,2})(\w+)/g;
-var parseSubstrateDerivations = (derivationsStr) => {
-  const derivations = [];
-  if (derivations)
-    for (const [_, type, code] of derivationsStr.matchAll(DERIVATION_RE)) {
-      derivations.push([type === "//" ? "hard" : "soft", code]);
-    }
-  return derivations;
-};
-var createChainCode = (code) => {
-  const chainCode = new Uint8Array(32);
-  chainCode.set(Number.isNaN(+code) ? import_scale_ts.str.enc(code) : import_scale_ts.u32.enc(+code));
-  return chainCode;
-};
-var derivationCodec = /* @__PURE__ */ (0, import_scale_ts.Tuple)(import_scale_ts.str, (0, import_scale_ts.Bytes)(32), (0, import_scale_ts.Bytes)(32));
-var createSubstrateDeriveFn = (prefix) => (seed, chainCode) => blake2b256(derivationCodec.enc([prefix, seed, chainCode]));
-var deriveSubstrateSecretKey = (seed, derivationPath, prefix) => {
-  const derivations = parseSubstrateDerivations(derivationPath);
-  const derive = createSubstrateDeriveFn(prefix);
-  return derivations.reduce((seed2, [type, chainCode]) => {
-    const code = createChainCode(chainCode);
-    if (type === "soft") throw new Error("Soft derivations are not supported");
-    return derive(seed2, code);
-  }, seed);
-};
-
-// src/derivation/deriveEcdsa.ts
-var deriveEcdsa = (seed, derivationPath) => {
-  const secretKey = deriveSubstrateSecretKey(seed, derivationPath, "Secp256k1HDKD");
-  const publicKey = getPublicKeyEcdsa(secretKey);
-  return {
-    type: "ecdsa",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ss58")
-  };
-};
-var getPublicKeyEcdsa = (secretKey) => {
-  return import_secp256k1.secp256k1.getPublicKey(secretKey);
-};
-
-// src/derivation/deriveEd25519.ts
-var import_ed255193 = require("@noble/curves/ed25519.js");
-var deriveEd25519 = (seed, derivationPath) => {
-  const secretKey = deriveSubstrateSecretKey(seed, derivationPath, "Ed25519HDKD");
-  const publicKey = getPublicKeyEd25519(secretKey);
-  return {
-    type: "ed25519",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ss58")
-  };
-};
-var getPublicKeyEd25519 = (secretKey) => {
-  if (secretKey.length === 64) {
-    const [privateComponent, publicComponent] = [secretKey.slice(0, 32), secretKey.slice(32)];
-    const publicKey = import_ed255193.ed25519.getPublicKey(privateComponent);
-    if (!isUint8ArrayEq(publicComponent, publicKey)) return import_ed255193.ed25519.getPublicKey(secretKey);
-    return publicKey;
-  }
-  return import_ed255193.ed25519.getPublicKey(secretKey);
-};
-var isUint8ArrayEq = (a, b) => (
-  // biome-ignore lint/complexity/noUselessTernary: legacy
-  a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true
-);
-
-// src/derivation/deriveEthereum.ts
-var import_secp256k12 = require("@noble/curves/secp256k1.js");
-var import_bip32 = require("@scure/bip32");
-var deriveEthereum = (seed, derivationPath) => {
-  const hdkey = import_bip32.HDKey.fromMasterSeed(seed);
-  const childKey = hdkey.derive(derivationPath);
-  if (!childKey.privateKey) throw new Error("Invalid derivation path");
-  const secretKey = new Uint8Array(childKey.privateKey);
-  const publicKey = getPublicKeyEthereum(secretKey);
-  return {
-    type: "ethereum",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ethereum")
-  };
-};
-var getPublicKeyEthereum = (secretKey) => {
-  return import_secp256k12.secp256k1.getPublicKey(secretKey, false);
-};
-
-// src/derivation/deriveSr25519.ts
-var import_sr25519 = require("@scure/sr25519");
-var deriveSr25519 = (seed, derivationPath) => {
-  const derivations = parseSubstrateDerivations(derivationPath);
-  const secretKey = derivations.reduce((secretKey2, [type, chainCode]) => {
-    const code = createChainCode(chainCode);
-    return type === "hard" ? import_sr25519.HDKD.secretHard(secretKey2, code) : import_sr25519.HDKD.secretSoft(secretKey2, code);
-  }, (0, import_sr25519.secretFromSeed)(seed));
-  const publicKey = getPublicKeySr25519(secretKey);
-  return {
-    type: "sr25519",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ss58")
-  };
-};
-var getPublicKeySr25519 = import_sr25519.getPublicKey;
-
-// src/derivation/utils.ts
-var deriveKeypair = (seed, derivationPath, curve) => {
-  switch (curve) {
-    case "sr25519":
-      return deriveSr25519(seed, derivationPath);
-    case "ed25519":
-      return deriveEd25519(seed, derivationPath);
-    case "ecdsa":
-      return deriveEcdsa(seed, derivationPath);
-    case "bitcoin-ecdsa":
-    case "bitcoin-ed25519":
-      throw new Error("deriveKeypair is not implemented for Bitcoin");
-    case "ethereum":
-      return deriveEthereum(seed, derivationPath);
-    case "solana":
-      return deriveSolana(seed, derivationPath);
-  }
-};
-var getPublicKeyFromSecret = (secretKey, curve) => {
-  switch (curve) {
-    case "ecdsa":
-      return getPublicKeyEcdsa(secretKey);
-    case "ethereum":
-      return getPublicKeyEthereum(secretKey);
-    case "sr25519":
-      return getPublicKeySr25519(secretKey);
-    case "ed25519":
-      return getPublicKeyEd25519(secretKey);
-    case "bitcoin-ecdsa":
-    case "bitcoin-ed25519":
-      throw new Error("getPublicKeyFromSecret is not implemented for Bitcoin");
-    case "solana":
-      return getPublicKeySolana(secretKey);
-  }
-};
-var addressFromMnemonic = async (mnemonic, derivationPath, curve) => {
-  const entropy = mnemonicToEntropy(mnemonic);
-  const seed = await entropyToSeed(entropy, curve);
-  const { address } = deriveKeypair(seed, derivationPath, curve);
-  return address;
-};
-var removeHexPrefix = (secretKey) => {
-  if (secretKey.startsWith("0x")) return secretKey.slice(2);
-  return secretKey;
-};
-var parseSecretKey = (secretKey, platform) => {
-  switch (platform) {
-    case "ethereum": {
-      const privateKey = removeHexPrefix(secretKey);
-      return import_base5.hex.decode(privateKey);
-    }
-    case "solana": {
-      const bytes = secretKey.startsWith("[") ? (
-        // JSON bytes array (ex: solflare)
-        Uint8Array.from(JSON.parse(secretKey))
-      ) : (
-        // base58 encoded string (ex: phantom)
-        import_base5.base58.decode(secretKey)
-      );
-      if (bytes.length === 64) {
-        const privateKey = bytes.slice(0, 32);
-        const publicKey = bytes.slice(32, 64);
-        const computedPublicKey = getPublicKeySolana(privateKey);
-        if (!publicKey.every((b, i) => b === computedPublicKey[i]))
-          throw new Error("Invalid Solana secret key: public key does not match");
-        return privateKey;
-      } else if (bytes.length === 32) return bytes;
-      throw new Error("Invalid Solana secret key length");
-    }
-    default:
-      throw new Error("Not implemented");
-  }
-};
-var isValidDerivationPath = async (derivationPath, curve) => {
-  try {
-    deriveKeypair(await getDevSeed(curve), derivationPath, curve);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/encryption/encryptKemAead.ts
-var import_chacha = require("@noble/ciphers/chacha.js");
-var import_utils3 = require("@noble/ciphers/utils.js");
-var import_mlkem = require("mlkem");
-var encryptKemAead = async (keyHash, publicKey, plaintext) => {
-  if (keyHash.length !== 16) {
-    throw new Error(`Expected 16-byte keyHash, got ${keyHash.length}`);
-  }
-  const kem = new import_mlkem.MlKem768();
-  const [kemCt, sharedSecret] = await kem.encap(publicKey);
-  if (sharedSecret.length !== 32) {
-    throw new Error(`Expected 32-byte shared secret, got ${sharedSecret.length}`);
-  }
-  const nonce = crypto.getRandomValues(new Uint8Array(24));
-  const aead = (0, import_chacha.xchacha20poly1305)(sharedSecret, nonce);
-  const aeadCt = aead.encrypt(plaintext);
-  const kemLen = new Uint8Array(2);
-  new DataView(kemLen.buffer).setUint16(0, kemCt.length, true);
-  return (0, import_utils3.concatBytes)(keyHash, kemLen, kemCt, nonce, aeadCt);
-};
-
-// src/platform/index.ts
-var getAccountPlatformFromCurve = (curve) => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "polkadot";
-    case "ethereum":
-      return "ethereum";
-    case "bitcoin-ecdsa":
-    case "bitcoin-ed25519":
-      return "bitcoin";
-    case "solana":
-      return "solana";
-  }
-};
-var getAccountPlatformFromEncoding = (encoding) => {
-  switch (encoding) {
-    case "ss58":
-      return "polkadot";
-    case "ethereum":
-      return "ethereum";
-    case "bech32m":
-    case "bech32":
-    case "base58check":
-      return "bitcoin";
-    case "base58solana":
-      return "solana";
-  }
-};
-var getAccountPlatformFromAddress = (address) => {
-  const encoding = detectAddressEncoding(address);
-  return getAccountPlatformFromEncoding(encoding);
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DEV_MNEMONIC_ETHEREUM,
-  DEV_MNEMONIC_POLKADOT,
-  addressEncodingFromCurve,
-  addressFromMnemonic,
-  addressFromPublicKey,
-  base58,
-  base64,
-  blake2b256,
-  blake2b512,
-  blake3,
-  checksumEthereumAddress,
-  decodeSs58Address,
-  deriveKeypair,
-  detectAddressEncoding,
-  ed25519,
-  encodeAddressEthereum,
-  encodeAddressSolana,
-  encodeAddressSs58,
-  encodeAnyAddress,
-  encryptKemAead,
-  entropyToMnemonic,
-  entropyToSeed,
-  fromBase58Check,
-  fromBech32,
-  fromBech32m,
-  generateMnemonic,
-  getAccountPlatformFromAddress,
-  getAccountPlatformFromCurve,
-  getAccountPlatformFromEncoding,
-  getDevSeed,
-  getPublicKeyFromSecret,
-  getPublicKeySolana,
-  getSafeHash,
-  hex,
-  isAddressEqual,
-  isAddressValid,
-  isBase58CheckAddress,
-  isBech32Address,
-  isBech32mAddress,
-  isBitcoinAddress,
-  isEthereumAddress,
-  isSolanaAddress,
-  isSs58Address,
-  isValidDerivationPath,
-  isValidMnemonic,
-  mnemonicToEntropy,
-  normalizeAddress,
-  parseSecretKey,
-  pbkdf2,
-  removeHexPrefix,
-  utf8
+//#endregion
+//#region src/address/encoding/detectAddressEncoding.ts
+const CACHE$1 = /* @__PURE__ */ new Map();
+const detectAddressEncodingInner = (address) => {
+	if (isEthereumAddress(address)) return "ethereum";
+	if (isSs58Address(address)) return "ss58";
+	if (isSolanaAddress(address)) return "base58solana";
+	if (isBech32mAddress(address)) return "bech32m";
+	if (isBech32Address(address)) return "bech32";
+	if (isBase58CheckAddress(address)) return "base58check";
+	throw new Error(`Unknown address encoding`);
+};
+const detectAddressEncoding = (address) => {
+	if (!CACHE$1.has(address)) CACHE$1.set(address, detectAddressEncodingInner(address));
+	return CACHE$1.get(address);
+};
+//#endregion
+//#region src/address/addressFromPublicKey.ts
+const addressFromPublicKey = (publicKey, encoding, options) => {
+	switch (encoding) {
+		case "ss58": return encodeAddressSs58(publicKey, options?.ss58Prefix);
+		case "ethereum": return encodeAddressEthereum(publicKey);
+		case "base58solana": return encodeAddressSolana(publicKey);
+		case "bech32m":
+		case "bech32":
+		case "base58check": throw new Error("addressFromPublicKey is not implemented for Bitcoin");
+	}
+};
+//#endregion
+//#region src/address/normalizeAddress.ts
+const CACHE = /* @__PURE__ */ new Map();
+const normalizeAddress = (address) => {
+	try {
+		if (!CACHE.has(address)) CACHE.set(address, normalizeAnyAddress(address));
+		return CACHE.get(address);
+	} catch (cause) {
+		throw new Error(`Unable to normalize address: ${address}`, { cause });
+	}
+};
+const normalizeAnyAddress = (address) => {
+	switch (detectAddressEncoding(address)) {
+		case "ethereum": return checksumEthereumAddress(address);
+		case "bech32m":
+		case "bech32":
+		case "base58check":
+		case "base58solana": return address;
+		case "ss58": {
+			const [pk] = decodeSs58Address(address);
+			return encodeAddressSs58(pk, 42);
+		}
+	}
+};
+//#endregion
+//#region src/address/encodeAnyAddress.ts
+const encodeAnyAddress = (address, options) => {
+	if (detectAddressEncoding(address) === "ss58" && options?.ss58Format !== void 0) {
+		const [publicKey] = decodeSs58Address(address);
+		return encodeAddressSs58(publicKey, options?.ss58Format ?? 42);
+	}
+	return normalizeAddress(address);
+};
+//#endregion
+//#region src/address/isAddressEqual.ts
+const isAddressEqual = (address1, address2) => {
+	try {
+		return normalizeAddress(address1) === normalizeAddress(address2);
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/address/isAddressValid.ts
+const isAddressValid = (address) => {
+	try {
+		detectAddressEncoding(address);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/derivation/deriveSolana.ts
+const parseDerivationPath = (path) => {
+	if (!path.startsWith("m/")) throw new Error("Path must start with 'm/'");
+	return path.split("/").slice(1).map((p) => {
+		if (!p.endsWith("'")) throw new Error("Only hardened derivation is supported");
+		return parseInt(p.slice(0, -1), 10) + 2147483648;
+	});
+};
+const deriveSolana = (seed, derivationPath) => {
+	let I = (0, _noble_hashes_hmac_js.hmac)(_noble_hashes_sha2_js.sha512, new TextEncoder().encode("ed25519 seed"), seed);
+	let secretKey = I.slice(0, 32);
+	let chainCode = I.slice(32);
+	for (const index of parseDerivationPath(derivationPath)) {
+		const data = new Uint8Array(1 + secretKey.length + 4);
+		data.set([0], 0);
+		data.set(secretKey, 1);
+		data.set(new Uint8Array([
+			index >> 24 & 255,
+			index >> 16 & 255,
+			index >> 8 & 255,
+			index & 255
+		]), 1 + secretKey.length);
+		I = (0, _noble_hashes_hmac_js.hmac)(_noble_hashes_sha2_js.sha512, chainCode, data);
+		secretKey = I.slice(0, 32);
+		chainCode = I.slice(32);
+	}
+	const publicKey = getPublicKeySolana(secretKey);
+	return {
+		type: "solana",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "base58solana")
+	};
+};
+const getPublicKeySolana = (secretKey) => {
+	return _noble_curves_ed25519_js.ed25519.getPublicKey(secretKey);
+};
+//#endregion
+//#region src/utils/pbkdf2.ts
+const pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
+	const keyMaterial = await crypto.subtle.importKey("raw", entropy, "PBKDF2", false, ["deriveBits"]);
+	const derivedBits = await crypto.subtle.deriveBits({
+		name: "PBKDF2",
+		salt,
+		iterations,
+		hash
+	}, keyMaterial, outputLenBytes * 8);
+	return new Uint8Array(derivedBits);
+};
+//#endregion
+//#region src/mnemonic/index.ts
+const mnemonicToEntropy = (mnemonic) => {
+	return (0, _scure_bip39.mnemonicToEntropy)(mnemonic, _scure_bip39_wordlists_english_js.wordlist);
+};
+const entropyToMnemonic = (entropy) => {
+	return (0, _scure_bip39.entropyToMnemonic)(entropy, _scure_bip39_wordlists_english_js.wordlist);
+};
+const entropyToSeedSubstrate = async (entropy, password) => await pbkdf2("SHA-512", entropy, mnemonicPasswordToSalt(password ?? ""), 2048, 32);
+const entropyToSeedClassic = async (entropy, password) => await pbkdf2("SHA-512", encodeNormalized(entropyToMnemonic(entropy)), mnemonicPasswordToSalt(password ?? ""), 2048, 64);
+const mnemonicPasswordToSalt = (password) => encodeNormalized(`mnemonic${password}`);
+/** Normalizes a UTF-8 string using `NFKD` form, then encodes it into bytes */
+const encodeNormalized = (utf8) => new TextEncoder().encode(utf8.normalize("NFKD"));
+const getSeedDerivationType = (curve) => {
+	switch (curve) {
+		case "sr25519":
+		case "ed25519":
+		case "ecdsa": return "substrate";
+		case "ethereum":
+		case "solana": return "classic";
+		case "bitcoin-ecdsa":
+		case "bitcoin-ed25519": throw new Error("seed derivation is not implemented for Bitcoin");
+	}
+};
+const entropyToSeed = async (entropy, curve, password) => {
+	switch (getSeedDerivationType(curve)) {
+		case "classic": return await entropyToSeedClassic(entropy, password);
+		case "substrate": return await entropyToSeedSubstrate(entropy, password);
+	}
+};
+const isValidMnemonic = (mnemonic) => {
+	return (0, _scure_bip39.validateMnemonic)(mnemonic, _scure_bip39_wordlists_english_js.wordlist);
+};
+const generateMnemonic = (words) => {
+	switch (words) {
+		case 12: return (0, _scure_bip39.generateMnemonic)(_scure_bip39_wordlists_english_js.wordlist, 128);
+		case 24: return (0, _scure_bip39.generateMnemonic)(_scure_bip39_wordlists_english_js.wordlist, 256);
+	}
+};
+const DEV_MNEMONIC_POLKADOT = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
+const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test test junk";
+const DEV_SEED_CACHE = /* @__PURE__ */ new Map();
+const getDevSeed = async (curve) => {
+	const type = getSeedDerivationType(curve);
+	if (!DEV_SEED_CACHE.has(type)) switch (type) {
+		case "classic": {
+			const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM);
+			const seed = await entropyToSeedClassic(entropy);
+			DEV_SEED_CACHE.set(type, seed);
+			break;
+		}
+		case "substrate": {
+			const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
+			const seed = await entropyToSeedSubstrate(entropy);
+			DEV_SEED_CACHE.set(type, seed);
+			break;
+		}
+		default: throw new Error("Unsupported derivation type");
+	}
+	return DEV_SEED_CACHE.get(type);
+};
+//#endregion
+//#region src/derivation/common.ts
+const DERIVATION_RE = /(\/{1,2})(\w+)/g;
+const parseSubstrateDerivations = (derivationsStr) => {
+	const derivations = [];
+	if (derivations) for (const [_, type, code] of derivationsStr.matchAll(DERIVATION_RE)) derivations.push([type === "//" ? "hard" : "soft", code]);
+	return derivations;
+};
+const createChainCode = (code) => {
+	const chainCode = /* @__PURE__ */ new Uint8Array(32);
+	chainCode.set(Number.isNaN(+code) ? scale_ts.str.enc(code) : scale_ts.u32.enc(+code));
+	return chainCode;
+};
+const derivationCodec = /* @__PURE__ */ (0, scale_ts.Tuple)(scale_ts.str, (0, scale_ts.Bytes)(32), (0, scale_ts.Bytes)(32));
+const createSubstrateDeriveFn = (prefix) => (seed, chainCode) => blake2b256(derivationCodec.enc([
+	prefix,
+	seed,
+	chainCode
+]));
+const deriveSubstrateSecretKey = (seed, derivationPath, prefix) => {
+	const derivations = parseSubstrateDerivations(derivationPath);
+	const derive = createSubstrateDeriveFn(prefix);
+	return derivations.reduce((seed, [type, chainCode]) => {
+		const code = createChainCode(chainCode);
+		if (type === "soft") throw new Error("Soft derivations are not supported");
+		return derive(seed, code);
+	}, seed);
+};
+//#endregion
+//#region src/derivation/deriveEcdsa.ts
+const deriveEcdsa = (seed, derivationPath) => {
+	const secretKey = deriveSubstrateSecretKey(seed, derivationPath, "Secp256k1HDKD");
+	const publicKey = getPublicKeyEcdsa(secretKey);
+	return {
+		type: "ecdsa",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "ss58")
+	};
+};
+const getPublicKeyEcdsa = (secretKey) => {
+	return _noble_curves_secp256k1_js.secp256k1.getPublicKey(secretKey);
+};
+//#endregion
+//#region src/derivation/deriveEd25519.ts
+const deriveEd25519 = (seed, derivationPath) => {
+	const secretKey = deriveSubstrateSecretKey(seed, derivationPath, "Ed25519HDKD");
+	const publicKey = getPublicKeyEd25519(secretKey);
+	return {
+		type: "ed25519",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "ss58")
+	};
+};
+const getPublicKeyEd25519 = (secretKey) => {
+	if (secretKey.length === 64) {
+		const [privateComponent, publicComponent] = [secretKey.slice(0, 32), secretKey.slice(32)];
+		const publicKey = _noble_curves_ed25519_js.ed25519.getPublicKey(privateComponent);
+		if (!isUint8ArrayEq(publicComponent, publicKey)) return _noble_curves_ed25519_js.ed25519.getPublicKey(secretKey);
+		return publicKey;
+	}
+	return _noble_curves_ed25519_js.ed25519.getPublicKey(secretKey);
+};
+/** If a is identical to b, this function returns true, otherwise it returns false */
+const isUint8ArrayEq = (a, b) => a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true;
+//#endregion
+//#region src/derivation/deriveEthereum.ts
+const deriveEthereum = (seed, derivationPath) => {
+	const childKey = _scure_bip32.HDKey.fromMasterSeed(seed).derive(derivationPath);
+	if (!childKey.privateKey) throw new Error("Invalid derivation path");
+	const secretKey = new Uint8Array(childKey.privateKey);
+	const publicKey = getPublicKeyEthereum(secretKey);
+	return {
+		type: "ethereum",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "ethereum")
+	};
+};
+const getPublicKeyEthereum = (secretKey) => {
+	return _noble_curves_secp256k1_js.secp256k1.getPublicKey(secretKey, false);
+};
+//#endregion
+//#region src/derivation/deriveSr25519.ts
+const deriveSr25519 = (seed, derivationPath) => {
+	const secretKey = parseSubstrateDerivations(derivationPath).reduce((secretKey, [type, chainCode]) => {
+		const code = createChainCode(chainCode);
+		return type === "hard" ? _scure_sr25519.HDKD.secretHard(secretKey, code) : _scure_sr25519.HDKD.secretSoft(secretKey, code);
+	}, (0, _scure_sr25519.secretFromSeed)(seed));
+	const publicKey = getPublicKeySr25519(secretKey);
+	return {
+		type: "sr25519",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "ss58")
+	};
+};
+const getPublicKeySr25519 = _scure_sr25519.getPublicKey;
+//#endregion
+//#region src/derivation/utils.ts
+const deriveKeypair = (seed, derivationPath, curve) => {
+	switch (curve) {
+		case "sr25519": return deriveSr25519(seed, derivationPath);
+		case "ed25519": return deriveEd25519(seed, derivationPath);
+		case "ecdsa": return deriveEcdsa(seed, derivationPath);
+		case "bitcoin-ecdsa":
+		case "bitcoin-ed25519": throw new Error("deriveKeypair is not implemented for Bitcoin");
+		case "ethereum": return deriveEthereum(seed, derivationPath);
+		case "solana": return deriveSolana(seed, derivationPath);
+	}
+};
+const getPublicKeyFromSecret = (secretKey, curve) => {
+	switch (curve) {
+		case "ecdsa": return getPublicKeyEcdsa(secretKey);
+		case "ethereum": return getPublicKeyEthereum(secretKey);
+		case "sr25519": return getPublicKeySr25519(secretKey);
+		case "ed25519": return getPublicKeyEd25519(secretKey);
+		case "bitcoin-ecdsa":
+		case "bitcoin-ed25519": throw new Error("getPublicKeyFromSecret is not implemented for Bitcoin");
+		case "solana": return getPublicKeySolana(secretKey);
+	}
+};
+const addressFromMnemonic = async (mnemonic, derivationPath, curve) => {
+	const seed = await entropyToSeed(mnemonicToEntropy(mnemonic), curve);
+	const { address } = deriveKeypair(seed, derivationPath, curve);
+	return address;
+};
+const removeHexPrefix = (secretKey) => {
+	if (secretKey.startsWith("0x")) return secretKey.slice(2);
+	return secretKey;
+};
+const parseSecretKey = (secretKey, platform) => {
+	switch (platform) {
+		case "ethereum": {
+			const privateKey = removeHexPrefix(secretKey);
+			return _scure_base.hex.decode(privateKey);
+		}
+		case "solana": {
+			const bytes = secretKey.startsWith("[") ? Uint8Array.from(JSON.parse(secretKey)) : _scure_base.base58.decode(secretKey);
+			if (bytes.length === 64) {
+				const privateKey = bytes.slice(0, 32);
+				const publicKey = bytes.slice(32, 64);
+				const computedPublicKey = getPublicKeySolana(privateKey);
+				if (!publicKey.every((b, i) => b === computedPublicKey[i])) throw new Error("Invalid Solana secret key: public key does not match");
+				return privateKey;
+			} else if (bytes.length === 32) return bytes;
+			throw new Error("Invalid Solana secret key length");
+		}
+		default: throw new Error("Not implemented");
+	}
+};
+const isValidDerivationPath = async (derivationPath, curve) => {
+	try {
+		deriveKeypair(await getDevSeed(curve), derivationPath, curve);
+		return true;
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/encryption/encryptKemAead.ts
+/**
+* Encrypts plaintext using ML-KEM-768 + XChaCha20-Poly1305 (KEM-AEAD).
+*
+* Wire format (subtensor pallet-shield v2):
+*   key_hash (16 bytes) || kem_len (2 bytes LE) || kem_ct (variable) || nonce (24 bytes) || aead_ct (variable)
+*
+* @param keyHash   16-byte xxhash128 of the public key (caller must compute, e.g. via Twox128)
+* @param publicKey ML-KEM-768 encapsulation key bytes
+* @param plaintext Data to encrypt (typically a signed extrinsic)
+*/
+const encryptKemAead = async (keyHash, publicKey, plaintext) => {
+	if (keyHash.length !== 16) throw new Error(`Expected 16-byte keyHash, got ${keyHash.length}`);
+	const [kemCt, sharedSecret] = await new mlkem.MlKem768().encap(publicKey);
+	if (sharedSecret.length !== 32) throw new Error(`Expected 32-byte shared secret, got ${sharedSecret.length}`);
+	const nonce = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(24));
+	const aeadCt = (0, _noble_ciphers_chacha_js.xchacha20poly1305)(sharedSecret, nonce).encrypt(plaintext);
+	const kemLen = /* @__PURE__ */ new Uint8Array(2);
+	new DataView(kemLen.buffer).setUint16(0, kemCt.length, true);
+	return (0, _noble_ciphers_utils_js.concatBytes)(keyHash, kemLen, kemCt, nonce, aeadCt);
+};
+//#endregion
+//#region src/keystore/index.ts
+/**
+* polkadot-js encrypted keystore JSON support (scrypt + xsalsa20-poly1305), byte-compatible
+* with `@polkadot/util-crypto` `jsonEncrypt`/`jsonDecrypt`.
+*
+* Layout of the base64 `encoded` blob:
+*   salt(32) ++ N(u32 LE) ++ p(u32 LE) ++ r(u32 LE) ++ nonce(24) ++ ciphertext
+*/
+const SALT_LENGTH = 32;
+const NONCE_LENGTH = 24;
+const ALLOWED_SCRYPT_PARAMS = [
+	{
+		N: 8192,
+		p: 10,
+		r: 8
+	},
+	{
+		N: 16384,
+		p: 5,
+		r: 8
+	},
+	{
+		N: 32768,
+		p: 3,
+		r: 8
+	},
+	{
+		N: 32768,
+		p: 1,
+		r: 8
+	},
+	{
+		N: 65536,
+		p: 2,
+		r: 8
+	},
+	{
+		N: 1 << 17,
+		p: 1,
+		r: 8
+	}
+];
+const SCRYPT_N = 1 << 17;
+const SCRYPT_P = 1;
+const SCRYPT_R = 8;
+const readU32LE = (bytes, offset) => bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24 >>> 0;
+const writeU32LE = (value) => new Uint8Array([
+	value & 255,
+	value >> 8 & 255,
+	value >> 16 & 255,
+	value >> 24 & 255
+]);
+const deriveKey = (password, salt, params) => (0, _noble_hashes_scrypt_js.scrypt)(new TextEncoder().encode(password), salt, {
+	...params,
+	dkLen: 64
+}).subarray(0, 32);
+/** Decrypts a polkadot-js encrypted keystore (`jsonDecrypt` equivalent) */
+const decryptPjsKeystore = ({ encoded, encoding }, password) => {
+	if (!encoded) throw new Error("No encrypted data available to decode");
+	const bytes = _scure_base.base64.decode(encoded);
+	if (!encoding.type.includes("xsalsa20-poly1305")) {
+		if (encoding.type.includes("none")) return bytes;
+		throw new Error(`Unsupported keystore encoding: ${encoding.type.join("/")}`);
+	}
+	let offset = 0;
+	let key;
+	if (encoding.type.includes("scrypt")) {
+		const salt = bytes.subarray(0, SALT_LENGTH);
+		const N = readU32LE(bytes, SALT_LENGTH);
+		const p = readU32LE(bytes, 36);
+		const r = readU32LE(bytes, 40);
+		if (!ALLOWED_SCRYPT_PARAMS.some((preset) => preset.N === N && preset.p === p && preset.r === r)) throw new Error("Invalid injected scrypt params found");
+		key = deriveKey(password, salt, {
+			N,
+			p,
+			r
+		});
+		offset = 44;
+	} else {
+		const padded = /* @__PURE__ */ new Uint8Array(32);
+		padded.set(new TextEncoder().encode(password).subarray(0, 32));
+		key = padded;
+	}
+	const nonce = bytes.subarray(offset, offset + NONCE_LENGTH);
+	const ciphertext = bytes.subarray(offset + NONCE_LENGTH);
+	return (0, _noble_ciphers_salsa_js.xsalsa20poly1305)(key, nonce).decrypt(ciphertext);
+};
+/** Encrypts data as a polkadot-js keystore (`jsonEncrypt` equivalent, always scrypt + v3) */
+const encryptPjsKeystore = (data, contentType, password) => {
+	const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+	const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
+	const ciphertext = (0, _noble_ciphers_salsa_js.xsalsa20poly1305)(deriveKey(password, salt, {
+		N: SCRYPT_N,
+		p: SCRYPT_P,
+		r: SCRYPT_R
+	}), nonce).encrypt(data);
+	const encoded = new Uint8Array(68 + ciphertext.length);
+	encoded.set(salt, 0);
+	encoded.set(writeU32LE(SCRYPT_N), SALT_LENGTH);
+	encoded.set(writeU32LE(SCRYPT_P), 36);
+	encoded.set(writeU32LE(SCRYPT_R), 40);
+	encoded.set(nonce, 44);
+	encoded.set(ciphertext, 68);
+	return {
+		encoded: _scure_base.base64.encode(encoded),
+		encoding: {
+			content: contentType,
+			type: ["scrypt", "xsalsa20-poly1305"],
+			version: "3"
+		}
+	};
+};
+//#endregion
+//#region src/platform/index.ts
+const getAccountPlatformFromCurve = (curve) => {
+	switch (curve) {
+		case "sr25519":
+		case "ed25519":
+		case "ecdsa": return "polkadot";
+		case "ethereum": return "ethereum";
+		case "bitcoin-ecdsa":
+		case "bitcoin-ed25519": return "bitcoin";
+		case "solana": return "solana";
+	}
+};
+const getAccountPlatformFromEncoding = (encoding) => {
+	switch (encoding) {
+		case "ss58": return "polkadot";
+		case "ethereum": return "ethereum";
+		case "bech32m":
+		case "bech32":
+		case "base58check": return "bitcoin";
+		case "base58solana": return "solana";
+	}
+};
+const getAccountPlatformFromAddress = (address) => {
+	const encoding = detectAddressEncoding(address);
+	return getAccountPlatformFromEncoding(encoding);
+};
+//#endregion
+//#region src/signing/index.ts
+/** noble's recovered signature format is v||r||s, substrate expects r||s||v */
+const toRsv = (vrs) => {
+	const rsv = /* @__PURE__ */ new Uint8Array(65);
+	rsv.set(vrs.subarray(1), 0);
+	rsv[64] = vrs[0];
+	return rsv;
+};
+/**
+* Signs a substrate payload with the given curve.
+*
+* Output is byte-compatible with polkadot-js `KeyringPair.sign` (without type prefix):
+* - sr25519/ed25519: 64-byte signature over the raw message
+* - ecdsa: 65-byte recoverable signature (r||s||v) over blake2b-256(message)
+* - ethereum: 65-byte recoverable signature (r||s||v) over keccak-256(message)
+*
+* Note: callers are responsible for the substrate >256-byte rule (hash the payload
+* with blake2b-256 before signing) — this matches where polkadot-js applies it.
+*/
+const signSubstrate = (curve, secretKey, message) => {
+	switch (curve) {
+		case "sr25519": return (0, _scure_sr25519.sign)(secretKey, message);
+		case "ed25519": return _noble_curves_ed25519_js.ed25519.sign(message, secretKey.length === 64 ? secretKey.subarray(0, 32) : secretKey);
+		case "ecdsa": return toRsv(_noble_curves_secp256k1_js.secp256k1.sign(blake2b256(message), secretKey, {
+			format: "recovered",
+			prehash: false
+		}));
+		case "ethereum": return toRsv(_noble_curves_secp256k1_js.secp256k1.sign((0, _noble_hashes_sha3_js.keccak_256)(message), secretKey, {
+			format: "recovered",
+			prehash: false
+		}));
+		default: throw new Error(`Unsupported curve for substrate signing: ${curve}`);
+	}
+};
+/** MultiSignature enum variant index per signature scheme, used to type-prefix signatures */
+const SIGNATURE_TYPE_PREFIX = {
+	ed25519: 0,
+	sr25519: 1,
+	ecdsa: 2,
+	ethereum: 2
+};
+//#endregion
+exports.DEV_MNEMONIC_ETHEREUM = DEV_MNEMONIC_ETHEREUM;
+exports.DEV_MNEMONIC_POLKADOT = DEV_MNEMONIC_POLKADOT;
+exports.SIGNATURE_TYPE_PREFIX = SIGNATURE_TYPE_PREFIX;
+exports.addressEncodingFromCurve = addressEncodingFromCurve;
+exports.addressFromMnemonic = addressFromMnemonic;
+exports.addressFromPublicKey = addressFromPublicKey;
+Object.defineProperty(exports, "base58", {
+	enumerable: true,
+	get: function() {
+		return _scure_base.base58;
+	}
+});
+Object.defineProperty(exports, "base64", {
+	enumerable: true,
+	get: function() {
+		return _scure_base.base64;
+	}
+});
+exports.blake2b256 = blake2b256;
+exports.blake2b512 = blake2b512;
+exports.blake3 = blake3;
+exports.checksumEthereumAddress = checksumEthereumAddress;
+exports.decodeSs58Address = decodeSs58Address;
+exports.decryptPjsKeystore = decryptPjsKeystore;
+exports.deriveKeypair = deriveKeypair;
+exports.detectAddressEncoding = detectAddressEncoding;
+Object.defineProperty(exports, "ed25519", {
+	enumerable: true,
+	get: function() {
+		return _noble_curves_ed25519_js.ed25519;
+	}
 });
+exports.encodeAddressEthereum = encodeAddressEthereum;
+exports.encodeAddressSolana = encodeAddressSolana;
+exports.encodeAddressSs58 = encodeAddressSs58;
+exports.encodeAnyAddress = encodeAnyAddress;
+exports.encryptKemAead = encryptKemAead;
+exports.encryptPjsKeystore = encryptPjsKeystore;
+exports.entropyToMnemonic = entropyToMnemonic;
+exports.entropyToSeed = entropyToSeed;
+exports.fromBase58Check = fromBase58Check;
+exports.fromBech32 = fromBech32;
+exports.fromBech32m = fromBech32m;
+exports.generateMnemonic = generateMnemonic;
+exports.getAccountPlatformFromAddress = getAccountPlatformFromAddress;
+exports.getAccountPlatformFromCurve = getAccountPlatformFromCurve;
+exports.getAccountPlatformFromEncoding = getAccountPlatformFromEncoding;
+exports.getDevSeed = getDevSeed;
+exports.getPublicKeyFromSecret = getPublicKeyFromSecret;
+exports.getPublicKeySolana = getPublicKeySolana;
+exports.getSafeHash = getSafeHash;
+Object.defineProperty(exports, "hex", {
+	enumerable: true,
+	get: function() {
+		return _scure_base.hex;
+	}
+});
+exports.isAddressEqual = isAddressEqual;
+exports.isAddressValid = isAddressValid;
+exports.isBase58CheckAddress = isBase58CheckAddress;
+exports.isBech32Address = isBech32Address;
+exports.isBech32mAddress = isBech32mAddress;
+exports.isBitcoinAddress = isBitcoinAddress;
+exports.isEthereumAddress = isEthereumAddress;
+exports.isOnCurveSolanaAddress = isOnCurveSolanaAddress;
+exports.isSolanaAddress = isSolanaAddress;
+exports.isSs58Address = isSs58Address;
+exports.isValidDerivationPath = isValidDerivationPath;
+exports.isValidMnemonic = isValidMnemonic;
+exports.mnemonicToEntropy = mnemonicToEntropy;
+exports.normalizeAddress = normalizeAddress;
+exports.parseSecretKey = parseSecretKey;
+exports.pbkdf2 = pbkdf2;
+exports.removeHexPrefix = removeHexPrefix;
+exports.signSubstrate = signSubstrate;
+Object.defineProperty(exports, "utf8", {
+	enumerable: true,
+	get: function() {
+		return _scure_base.utf8;
+	}
+});
+
 //# sourceMappingURL=index.js.map