@talismn/crypto 0.0.0-pr2277-20251211071316 → 0.0.0-pr2295-20260110031023

package/dist/index.js

@@ -0,0 +1,808 @@
+"use strict";
+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_base.base58,
+  base64: () => import_base.base64,
+  blake2b256: () => blake2b256,
+  blake2b512: () => blake2b512,
+  blake3: () => blake3,
+  checksumEthereumAddress: () => checksumEthereumAddress,
+  decodeSs58Address: () => decodeSs58Address,
+  deriveKeypair: () => deriveKeypair,
+  detectAddressEncoding: () => detectAddressEncoding,
+  ed25519: () => import_ed25519.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_base.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_base.utf8
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/mnemonic/index.ts
+var import_bip39 = require("@scure/bip39");
+var import_english = require("@scure/bip39/wordlists/english");
+
+// src/utils/exports.ts
+var import_base = require("@scure/base");
+var import_ed25519 = require("@noble/curves/ed25519");
+
+// 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/utils.ts
+var import_base5 = require("@scure/base");
+
+// src/derivation/deriveEcdsa.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+
+// 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/solana.ts
+var import_base2 = 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_base2.base58.encode(publicKey);
+};
+function isSolanaAddress(address) {
+  try {
+    const bytes = import_base2.base58.decode(address);
+    return bytes.length === 32;
+  } catch (error) {
+    return false;
+  }
+}
+
+// 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);
+function isBech32mAddress(address) {
+  try {
+    fromBech32m(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBech32Address(address) {
+  try {
+    fromBech32(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBase58CheckAddress(address) {
+  try {
+    fromBase58Check(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+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)
+  };
+}
+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)
+  };
+}
+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");
+    }
+    const buf = Buffer.from(buffer);
+    return buf.readUInt8(offset);
+  }
+  const version = readUInt8(payload, 0);
+  const hash = payload.slice(1);
+  return { version, hash };
+}
+
+// src/address/encoding/ethereum.ts
+var import_sha3 = require("@noble/hashes/sha3");
+var import_utils2 = require("@noble/hashes/utils");
+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_utils2.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_utils2.bytesToHex)(hash);
+  const checksum = addr.split("").map((char, i) => parseInt(hashHex[i], 16) >= 8 ? char.toUpperCase() : char).join("");
+  return `0x${checksum}`;
+};
+function isEthereumAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+
+// src/address/encoding/ss58.ts
+var import_base4 = require("@scure/base");
+
+// src/hashing/index.ts
+var import_blake2b = require("@noble/hashes/blake2b");
+var import_blake3 = require("@noble/hashes/blake3");
+var import_base3 = require("@scure/base");
+var blake3 = import_blake3.blake3;
+var blake2b256 = (msg) => (0, import_blake2b.blake2b)(msg, { dkLen: 32 });
+var blake2b512 = (msg) => (0, import_blake2b.blake2b)(msg, { dkLen: 64 });
+var getSafeHash = (bytes) => {
+  return import_base3.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_base4.base58.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
+};
+var VALID_ADDRESS_LENGTHS = [35, 36, 37];
+var decodeSs58Address = (addressStr) => {
+  const address = import_base4.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);
+};
+function isSs58Address(address) {
+  try {
+    decodeSs58Address(address);
+    return true;
+  } catch (error) {
+    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/isAddressEqual.ts
+var isAddressEqual = (address1, address2) => {
+  try {
+    return normalizeAddress(address1) === normalizeAddress(address2);
+  } catch (err) {
+    return false;
+  }
+};
+
+// 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/isAddressValid.ts
+var isAddressValid = (address) => {
+  try {
+    detectAddressEncoding(address);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// 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_ed255192 = require("@noble/curves/ed25519");
+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_ed255192.ed25519.getPublicKey(privateComponent);
+    if (!isUint8ArrayEq(publicComponent, publicKey)) return import_ed255192.ed25519.getPublicKey(secretKey);
+    return publicKey;
+  }
+  return import_ed255192.ed25519.getPublicKey(secretKey);
+};
+var isUint8ArrayEq = (a, b) => a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true;
+
+// src/derivation/deriveEthereum.ts
+var import_secp256k12 = require("@noble/curves/secp256k1");
+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) => {
+  const scalar = import_secp256k12.secp256k1.utils.normPrivateKeyToScalar(secretKey);
+  return import_secp256k12.secp256k1.getPublicKey(scalar, false);
+};
+
+// src/derivation/deriveSolana.ts
+var import_ed255193 = require("@noble/curves/ed25519");
+var import_hmac = require("@noble/hashes/hmac");
+var import_sha512 = require("@noble/hashes/sha512");
+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_sha512.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_sha512.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_ed255193.ed25519.getPublicKey(secretKey);
+};
+
+// src/derivation/deriveSr25519.ts
+var import_utils3 = require("@noble/hashes/utils");
+var import_micro_sr25519 = require("micro-sr25519");
+var deriveSr25519 = (seed, derivationPath) => {
+  const derivations = parseSubstrateDerivations(derivationPath);
+  const secretKey = derivations.reduce((secretKey2, [type, chainCode]) => {
+    const deriveFn = type === "hard" ? import_micro_sr25519.HDKD.secretHard : import_micro_sr25519.HDKD.secretSoft;
+    const code = createChainCode(chainCode);
+    return deriveFn(secretKey2, code, import_utils3.randomBytes);
+  }, (0, import_micro_sr25519.secretFromSeed)(seed));
+  const publicKey = getPublicKeySr25519(secretKey);
+  return {
+    type: "sr25519",
+    secretKey,
+    publicKey,
+    address: addressFromPublicKey(publicKey, "ss58")
+  };
+};
+var getPublicKeySr25519 = import_micro_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 (err) {
+    return false;
+  }
+};
+
+// 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);
+};
+
+// src/encryption/encryptKemAead.ts
+var import_chacha = require("@noble/ciphers/chacha.js");
+var import_utils4 = require("@noble/ciphers/utils.js");
+var import_mlkem = require("mlkem");
+var encryptKemAead = async (publicKey, plaintext) => {
+  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_utils4.concatBytes)(kemLen, kemCt, nonce, aeadCt);
+};
+// 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
+});
+//# sourceMappingURL=index.js.map