@talismn/crypto 0.3.5 → 1.0.0

package/dist/index.mjs

@@ -1,734 +1,773 @@
-// 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
 import { bech32, bech32m } from "bech32";
 import bs58check from "bs58check";
-var isBitcoinAddress = (address) => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { ed25519, ed25519 as ed25519$1 } from "@noble/curves/ed25519.js";
+import { base58, base58 as base58$1, base64, base64 as base64$1, hex, hex as hex$1, utf8 } from "@scure/base";
+import { blake2b } from "@noble/hashes/blake2.js";
+import { blake3 as blake3$1 } from "@noble/hashes/blake3.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha2.js";
+import { entropyToMnemonic as entropyToMnemonic$1, generateMnemonic as generateMnemonic$1, mnemonicToEntropy as mnemonicToEntropy$1, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { Bytes, Tuple, str, u32 } from "scale-ts";
+import { HDKey } from "@scure/bip32";
+import { HDKD, getPublicKey, secretFromSeed, sign } from "@scure/sr25519";
+import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { concatBytes } from "@noble/ciphers/utils.js";
+import { MlKem768 } from "mlkem";
+import { xsalsa20poly1305 } from "@noble/ciphers/salsa.js";
+import { scrypt } from "@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 = bech32m.decode(address);
-  const version = result.words[0];
-  if (version === 0) throw new TypeError(`${address} uses wrong encoding`);
-  const data = bech32m.fromWords(result.words.slice(1));
-  return {
-    version,
-    prefix: result.prefix,
-    data: Uint8Array.from(data)
-  };
+	const result = bech32m.decode(address);
+	const version = result.words[0];
+	if (version === 0) throw new TypeError(`${address} uses wrong encoding`);
+	const data = 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 = bech32.decode(address);
-  const version = result.words[0];
-  if (version !== 0) throw new TypeError(`${address} uses wrong encoding`);
-  const data = bech32.fromWords(result.words.slice(1));
-  return {
-    version,
-    prefix: result.prefix,
-    data: Uint8Array.from(data)
-  };
+	const result = bech32.decode(address);
+	const version = result.words[0];
+	if (version !== 0) throw new TypeError(`${address} uses wrong encoding`);
+	const data = 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 = bs58check.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.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
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import { bytesToHex } from "@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 = keccak_256(publicKeyWithoutPrefix);
-  const address = hash.slice(-20);
-  return checksumEthereumAddress(`0x${bytesToHex(address)}`);
-};
-var checksumEthereumAddress = (address) => {
-  const addr = address.toLowerCase().replace(/^0x/, "");
-  const hash = keccak_256(new TextEncoder().encode(addr));
-  const hashHex = 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 = secp256k1.Point.fromBytes(publicKey).toBytes(false);
+	if (publicKey[0] !== 4) throw new Error("Invalid public key format");
+	const address = keccak_256(publicKey.slice(1)).slice(-20);
+	return checksumEthereumAddress(`0x${bytesToHex(address)}`);
+};
+const checksumEthereumAddress = (address) => {
+	const addr = address.toLowerCase().replace(/^0x/, "");
+	const hashHex = bytesToHex(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
-import { base58 } from "@scure/base";
-var encodeAddressSolana = (publicKey) => {
-  if (publicKey.length !== 32)
-    throw new Error("Public key must be 32 bytes long for Solana base58 encoding");
-  return 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 base58$1.encode(publicKey);
 };
 function isSolanaAddress(address) {
-  try {
-    const bytes = base58.decode(address);
-    return bytes.length === 32;
-  } catch {
-    return false;
-  }
+	try {
+		return base58$1.decode(address).length === 32;
+	} catch {
+		return false;
+	}
 }
-
-// src/address/encoding/ss58.ts
-import { base58 as base583 } from "@scure/base";
-
-// src/hashing/index.ts
-import { blake2b } from "@noble/hashes/blake2.js";
-import { blake3 as blake3Hasher } from "@noble/hashes/blake3.js";
-import { base58 as base582 } from "@scure/base";
-var blake3 = blake3Hasher;
-var blake2b256 = (msg) => blake2b(msg, { dkLen: 32 });
-var blake2b512 = (msg) => blake2b(msg, { dkLen: 64 });
-var getSafeHash = (bytes) => {
-  return base582.encode(blake3Hasher(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 base583.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
-};
-var VALID_ADDRESS_LENGTHS = [35, 36, 37];
-var decodeSs58Address = (addressStr) => {
-  const address = base583.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 {
+		ed25519$1.Point.fromBytes(base58$1.decode(address));
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/hashing/index.ts
+const blake3 = blake3$1;
+const blake2b256 = (msg) => blake2b(msg, { dkLen: 32 });
+const blake2b512 = (msg) => blake2b(msg, { dkLen: 64 });
+const getSafeHash = (bytes) => {
+	return base58$1.encode(blake3$1(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 base58$1.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
+};
+const VALID_ADDRESS_LENGTHS = [
+	35,
+	36,
+	37
+];
+const decodeSs58Address = (addressStr, ignoreChecksum = false) => {
+	const address = base58$1.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;
+	}
 }
+//#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 = hmac(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 = hmac(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 ed25519$1.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 mnemonicToEntropy$1(mnemonic, wordlist);
+};
+const entropyToMnemonic = (entropy) => {
+	return entropyToMnemonic$1(entropy, 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 validateMnemonic(mnemonic, wordlist);
+};
+const generateMnemonic = (words) => {
+	switch (words) {
+		case 12: return generateMnemonic$1(wordlist, 128);
+		case 24: return generateMnemonic$1(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) ? str.enc(code) : u32.enc(+code));
+	return chainCode;
+};
+const derivationCodec = /* @__PURE__ */ Tuple(str, Bytes(32), 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 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 = ed25519$1.getPublicKey(privateComponent);
+		if (!isUint8ArrayEq(publicComponent, publicKey)) return ed25519$1.getPublicKey(secretKey);
+		return publicKey;
+	}
+	return ed25519$1.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 = 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 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" ? HDKD.secretHard(secretKey, code) : HDKD.secretSoft(secretKey, code);
+	}, secretFromSeed(seed));
+	const publicKey = getPublicKeySr25519(secretKey);
+	return {
+		type: "sr25519",
+		secretKey,
+		publicKey,
+		address: addressFromPublicKey(publicKey, "ss58")
+	};
+};
+const getPublicKeySr25519 = 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 hex$1.decode(privateKey);
+		}
+		case "solana": {
+			const bytes = secretKey.startsWith("[") ? Uint8Array.from(JSON.parse(secretKey)) : base58$1.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 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 = xchacha20poly1305(sharedSecret, nonce).encrypt(plaintext);
+	const kemLen = /* @__PURE__ */ new Uint8Array(2);
+	new DataView(kemLen.buffer).setUint16(0, kemCt.length, true);
+	return 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) => 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 = base64$1.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 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 = 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: base64$1.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 sign(secretKey, message);
+		case "ed25519": return ed25519$1.sign(message, secretKey.length === 64 ? secretKey.subarray(0, 32) : secretKey);
+		case "ecdsa": return toRsv(secp256k1.sign(blake2b256(message), secretKey, {
+			format: "recovered",
+			prehash: false
+		}));
+		case "ethereum": return toRsv(secp256k1.sign(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
+export { DEV_MNEMONIC_ETHEREUM, DEV_MNEMONIC_POLKADOT, SIGNATURE_TYPE_PREFIX, addressEncodingFromCurve, addressFromMnemonic, addressFromPublicKey, base58, base64, blake2b256, blake2b512, blake3, checksumEthereumAddress, decodeSs58Address, decryptPjsKeystore, deriveKeypair, detectAddressEncoding, ed25519, encodeAddressEthereum, encodeAddressSolana, encodeAddressSs58, encodeAnyAddress, encryptKemAead, encryptPjsKeystore, entropyToMnemonic, entropyToSeed, fromBase58Check, fromBech32, fromBech32m, generateMnemonic, getAccountPlatformFromAddress, getAccountPlatformFromCurve, getAccountPlatformFromEncoding, getDevSeed, getPublicKeyFromSecret, getPublicKeySolana, getSafeHash, hex, isAddressEqual, isAddressValid, isBase58CheckAddress, isBech32Address, isBech32mAddress, isBitcoinAddress, isEthereumAddress, isOnCurveSolanaAddress, isSolanaAddress, isSs58Address, isValidDerivationPath, isValidMnemonic, mnemonicToEntropy, normalizeAddress, parseSecretKey, pbkdf2, removeHexPrefix, signSubstrate, utf8 };
 
-// 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
-import { ed25519 } from "@noble/curves/ed25519.js";
-import { hmac } from "@noble/hashes/hmac.js";
-import { sha512 } from "@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 = hmac(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 = hmac(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 ed25519.getPublicKey(secretKey);
-};
-
-// src/derivation/utils.ts
-import { base58 as base585, hex as hex2 } from "@scure/base";
-
-// src/mnemonic/index.ts
-import {
-  entropyToMnemonic as entropyToMnemonicBip39,
-  generateMnemonic as generateMnemonicBip39,
-  mnemonicToEntropy as mnemonicToEntropyBip39,
-  validateMnemonic
-} from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-
-// src/utils/exports.ts
-import { ed25519 as ed255192 } from "@noble/curves/ed25519.js";
-import { base58 as base584, base64, hex, utf8 } from "@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 mnemonicToEntropyBip39(mnemonic, wordlist);
-};
-var entropyToMnemonic = (entropy) => {
-  return entropyToMnemonicBip39(entropy, 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 validateMnemonic(mnemonic, wordlist);
-};
-var generateMnemonic = (words) => {
-  switch (words) {
-    case 12:
-      return generateMnemonicBip39(wordlist, 128);
-    case 24:
-      return generateMnemonicBip39(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
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-
-// src/derivation/common.ts
-import { Bytes, str, Tuple, u32 } from "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) ? str.enc(code) : u32.enc(+code));
-  return chainCode;
-};
-var derivationCodec = /* @__PURE__ */ Tuple(str, Bytes(32), 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 secp256k1.getPublicKey(secretKey);
-};
-
-// src/derivation/deriveEd25519.ts
-import { ed25519 as ed255193 } from "@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 = ed255193.getPublicKey(privateComponent);
-    if (!isUint8ArrayEq(publicComponent, publicKey)) return ed255193.getPublicKey(secretKey);
-    return publicKey;
-  }
-  return ed255193.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
-import { secp256k1 as secp256k12 } from "@noble/curves/secp256k1.js";
-import { HDKey } from "@scure/bip32";
-var deriveEthereum = (seed, derivationPath) => {
-  const hdkey = 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 secp256k12.getPublicKey(secretKey, false);
-};
-
-// src/derivation/deriveSr25519.ts
-import { getPublicKey, HDKD, secretFromSeed } from "@scure/sr25519";
-var deriveSr25519 = (seed, derivationPath) => {
-  const derivations = parseSubstrateDerivations(derivationPath);
-  const secretKey = derivations.reduce((secretKey2, [type, chainCode]) => {
-    const code = createChainCode(chainCode);
-    return type === "hard" ? HDKD.secretHard(secretKey2, code) : HDKD.secretSoft(secretKey2, code);
-  }, secretFromSeed(seed));
-  const publicKey = getPublicKeySr25519(secretKey);
-  return {
-    type: "sr25519",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ss58")
-  };
-};
-var getPublicKeySr25519 = 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 hex2.decode(privateKey);
-    }
-    case "solana": {
-      const bytes = secretKey.startsWith("[") ? (
-        // JSON bytes array (ex: solflare)
-        Uint8Array.from(JSON.parse(secretKey))
-      ) : (
-        // base58 encoded string (ex: phantom)
-        base585.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
-import { xchacha20poly1305 } from "@noble/ciphers/chacha.js";
-import { concatBytes } from "@noble/ciphers/utils.js";
-import { MlKem768 } from "mlkem";
-var encryptKemAead = async (keyHash, publicKey, plaintext) => {
-  if (keyHash.length !== 16) {
-    throw new Error(`Expected 16-byte keyHash, got ${keyHash.length}`);
-  }
-  const kem = new 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 = xchacha20poly1305(sharedSecret, nonce);
-  const aeadCt = aead.encrypt(plaintext);
-  const kemLen = new Uint8Array(2);
-  new DataView(kemLen.buffer).setUint16(0, kemCt.length, true);
-  return 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);
-};
-export {
-  DEV_MNEMONIC_ETHEREUM,
-  DEV_MNEMONIC_POLKADOT,
-  addressEncodingFromCurve,
-  addressFromMnemonic,
-  addressFromPublicKey,
-  base584 as base58,
-  base64,
-  blake2b256,
-  blake2b512,
-  blake3,
-  checksumEthereumAddress,
-  decodeSs58Address,
-  deriveKeypair,
-  detectAddressEncoding,
-  ed255192 as 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
-};
 //# sourceMappingURL=index.mjs.map