@talismn/crypto 0.2.3 → 0.3.1

package/dist/index.mjs

@@ -0,0 +1,729 @@
+// 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);
+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 = 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)
+  };
+}
+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)
+  };
+}
+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");
+    }
+    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
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex } from "@noble/hashes/utils";
+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}`;
+};
+function isEthereumAddress(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);
+};
+function isSolanaAddress(address) {
+  try {
+    const bytes = base58.decode(address);
+    return bytes.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/blake2b";
+import { blake3 as blake3Hasher } from "@noble/hashes/blake3";
+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);
+};
+function isSs58Address(address) {
+  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
+import { ed25519 } from "@noble/curves/ed25519";
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@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 = 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";
+
+// src/utils/exports.ts
+import { ed25519 as ed255192 } from "@noble/curves/ed25519";
+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";
+
+// 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";
+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";
+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) => {
+  const scalar = secp256k12.utils.normPrivateKeyToScalar(secretKey);
+  return secp256k12.getPublicKey(scalar, false);
+};
+
+// src/derivation/deriveSr25519.ts
+import { randomBytes } from "@noble/hashes/utils";
+import { getPublicKey, HDKD, secretFromSeed } from "micro-sr25519";
+var deriveSr25519 = (seed, derivationPath) => {
+  const derivations = parseSubstrateDerivations(derivationPath);
+  const secretKey = derivations.reduce((secretKey2, [type, chainCode]) => {
+    const deriveFn = type === "hard" ? HDKD.secretHard : HDKD.secretSoft;
+    const code = createChainCode(chainCode);
+    return deriveFn(secretKey2, code, randomBytes);
+  }, 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 (publicKey, plaintext) => {
+  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(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