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

package/dist/talismn-crypto.esm.js

@@ -1,716 +0,0 @@
-import { mnemonicToEntropy as mnemonicToEntropy$1, entropyToMnemonic as entropyToMnemonic$1, validateMnemonic, generateMnemonic as generateMnemonic$1 } from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { base58, hex } from '@scure/base';
-export { base58, base64, hex, utf8 } from '@scure/base';
-import { ed25519 } from '@noble/curves/ed25519';
-export { ed25519 } from '@noble/curves/ed25519';
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { bech32m, bech32 } from 'bech32';
-import bs58check from 'bs58check';
-import { keccak_256 } from '@noble/hashes/sha3';
-import { bytesToHex, randomBytes } from '@noble/hashes/utils';
-import { blake2b } from '@noble/hashes/blake2b';
-import { blake3 as blake3$1 } from '@noble/hashes/blake3';
-import { Tuple, str, Bytes, u32 } from 'scale-ts';
-import { HDKey } from '@scure/bip32';
-import { hmac } from '@noble/hashes/hmac';
-import { sha512 } from '@noble/hashes/sha512';
-import { getPublicKey, HDKD, secretFromSeed } from 'micro-sr25519';
-import { xchacha20poly1305 } from '@noble/ciphers/chacha.js';
-import { concatBytes } from '@noble/ciphers/utils.js';
-import { MlKem768 } from 'mlkem';
-
-const pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
-  // NOTE: react-native-quick-crypto (our `global.crypto` polyfill on Talisman Mobile) doesn't support `crypto.subtle.deriveKey`.
-  // But, we can work around this by using `crypto.subtle.deriveBits` and `crypto.subtle.importKey`, which when used together
-  // can provide the same functionality as `crypto.subtle.deriveKey`.
-  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);
-};
-
-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,
-// 2048 iterations
-32 // 32 bytes (32 * 8 == 256 bits)
-);
-const entropyToSeedClassic = async (entropy, password) => await pbkdf2("SHA-512", encodeNormalized(entropyToMnemonic(entropy)), mnemonicPasswordToSalt(password ?? ""), 2048,
-// 2048 iterations
-64 // 64 bytes (64 * 8 == 512 bits)
-);
-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");
-  }
-};
-
-// when deriving keys from a mnemonic, we usually dont want a password here.
-// a password provided here would be used as a 25th mnemonic word.
-const 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);
-  }
-};
-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);
-  }
-};
-
-// well-known mnemonic used by polkadot.js, can be checked on polkadot wiki
-const DEV_MNEMONIC_POLKADOT = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
-
-// well-known phrase used by hardhat and anvil
-const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test test junk";
-
-// keep dev seeds in cache as we will reuse them to validate multiple derivation paths
-const DEV_SEED_CACHE = 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); // 80ms
-          DEV_SEED_CACHE.set(type, seed);
-          break;
-        }
-      case "substrate":
-        {
-          const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
-          const seed = await entropyToSeedSubstrate(entropy); // 80ms
-          DEV_SEED_CACHE.set(type, seed);
-          break;
-        }
-      default:
-        throw new Error("Unsupported derivation type");
-    }
-  }
-  return DEV_SEED_CACHE.get(type);
-};
-
-/** 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":
-      // NOTE: Bitcoin has multiple address formats, so this isn't necessarily correct
-      // The format MAY be bech32m, but it might also be bech32 or base58check.
-      // bech32m is the most recent format.
-      return "bech32m";
-    case "ethereum":
-      return "ethereum";
-    case "solana":
-      return "base58solana";
-  }
-};
-
-const 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 (error) {
-    return false;
-  }
-}
-
-const 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;
-}
-
-/**
- * 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)
-  };
-}
-
-/**
- * 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)
-  };
-}
-
-/**
- * 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");
-    }
-    const buf = Buffer.from(buffer);
-    return buf.readUInt8(offset);
-  }
-  const version = readUInt8(payload, 0);
-  const hash = payload.slice(1);
-  return {
-    version,
-    hash
-  };
-}
-
-/**
- * Encodes a public key using H160 encoding with Ethereum checksum.
- */
-const encodeAddressEthereum = publicKey => {
-  // Ensure the public key is in uncompressed format (starts with 0x04)
-  if (publicKey[0] !== 0x04) throw new Error("Invalid public key format");
-
-  // Remove the prefix (0x04)
-  const publicKeyWithoutPrefix = publicKey.slice(1);
-
-  // Apply Keccak-256 hashing to the public key
-  const hash = keccak_256(publicKeyWithoutPrefix);
-
-  // Take the last 20 bytes of the hash to get the Ethereum address
-  const address = hash.slice(-20);
-
-  // Apply checksum
-  return checksumEthereumAddress(`0x${bytesToHex(address)}`);
-};
-const 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);
-}
-
-// Note: public key cannot be retrieved from an address, because address is hashed from only the last 20 bytes of the pk
-
-const blake3 = blake3$1;
-const blake2b256 = msg => blake2b(msg, {
-  dkLen: 32
-});
-const blake2b512 = msg => blake2b(msg, {
-  dkLen: 64
-});
-const getSafeHash = bytes => {
-  // cryptographically secure one way hash
-  // outputs 44 characters without special characters
-  return base58.encode(blake3$1(bytes));
-};
-
-// Inspired from MIT licensed @polkadot-labs/hdkd-helpers
-// https://github.com/polkadot-labs/hdkd/blob/3ef6e02827212d934b59a4e566d8aa61d3ba7b27/packages/hdkd-helpers/src/accountId.ts#L3
-
-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 & 0b0000_0000_1111_1100) >> 2 | 0b0100_0000, prefix >> 8 | (prefix & 0b0000_0000_0000_0011) << 6);
-  const checksum = blake2b512(Uint8Array.of(...SS58PRE, ...prefixBytes, ...payload)).subarray(0, CHECKSUM_LENGTH);
-  return base58.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum));
-};
-const VALID_ADDRESS_LENGTHS = [35, 36, 37];
-const decodeSs58Address = addressStr => {
-  const address = 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] & 0b0100_0000 ? 2 : 1;
-  const prefix = prefixLength === 1 ? address[0] : (address[0] & 0b0011_1111) << 2 | address[1] >> 6 | (address[1] & 0b0011_1111) << 8;
-  const publicKey = address.slice(prefixLength, address.length - CHECKSUM_LENGTH);
-  return [publicKey, 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 (error) {
-    return false;
-  }
-}
-
-const CACHE$1 = 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);
-};
-
-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");
-  }
-};
-
-const CACHE = new Map();
-
-// Normalize an address in a way that it can be compared to other addresses that have also been normalized
-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);
-      }
-  }
-};
-
-const isAddressEqual = (address1, address2) => {
-  try {
-    return normalizeAddress(address1) === normalizeAddress(address2);
-  } catch (err) {
-    // if normalization fails, assume the addresses are not equal
-    return false;
-  }
-};
-
-const encodeAnyAddress = (address, options) => {
-  // this leverages cache
-  const encoding = detectAddressEncoding(address);
-
-  // this does NOT leverage cache
-  if (encoding === "ss58" && options?.ss58Format !== undefined) {
-    const [publicKey] = decodeSs58Address(address);
-    return encodeAddressSs58(publicKey, options?.ss58Format ?? 42);
-  }
-
-  // this leverages cache
-  return normalizeAddress(address);
-};
-
-const isAddressValid = address => {
-  try {
-    detectAddressEncoding(address);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// Inspired from MIT licensed @polkadot-labs/hdkd helpers
-// https://github.com/polkadot-labs/hdkd/blob/3ef6e02827212d934b59a4e566d8aa61d3ba7b27/packages/hdkd-helpers/src/parseDerivations.ts#L1
-
-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 = 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);
-};
-
-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);
-};
-
-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 => {
-  // When importing ed25519 polkadot-js accounts via json, which we do inside of `packages/extension-core/src/domains/keyring/getSecretKeyFromPjsJson.ts`,
-  // the secretKey we produce is 64 bytes in length.
-  //
-  // When using the ed25519 curve to derive a publicKey for this 64 bytes privateKey, we should only take the first 32 bytes:
-  // - https://github.com/paulmillr/noble-curves/issues/53#issuecomment-1577362759
-  // - https://github.com/paulmillr/noble-curves/discussions/33#discussioncomment-5685971
-  // - https://github.com/paulmillr/noble-curves/pull/54
-  // - https://github.com/paulmillr/noble-curves/issues/88
-  //
-  // When you compare the ed25519 publicKey of a given account produced by this function to the publicKey produced by
-  // polkadot-js, you will find that they are the same as eachother.
-  if (secretKey.length === 64) {
-    const [privateComponent, publicComponent] = [secretKey.slice(0, 32), secretKey.slice(32)];
-    const publicKey = ed25519.getPublicKey(privateComponent);
-
-    // NOTE: We only accept a 64 byte secretKey when the first 32 bytes successfully produce a public key which equals the second 32 bytes of the secretKey.
-    //
-    // In this scenario, we assume the creator of the secretKey has given us an array of bytes which equals `[...privateKey, ...publicKey]`.
-    //
-    // However, if the second 32 bytes **don't** match the publicKey produced by the first 32 bytes, we no longer know what's going on.
-    //
-    // In that case we pass the 64 bytes directly through to `@noble/curves/ed25519`, which we expect will throw the error: `private key of length 32 expected, got 64`.
-    // But if there's some 64 byte key format for ed25519 we don't know about, or one is added in the future, `@noble/curves/ed25519` can handle that for us instead of throwing.
-    if (!isUint8ArrayEq(publicComponent, publicKey)) return ed25519.getPublicKey(secretKey);
-    return publicKey;
-  }
-  return ed25519.getPublicKey(secretKey);
-};
-
-/** If a is identical to b, this function returns true, otherwise it returns false */
-const isUint8ArrayEq = (a, b) => a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true;
-
-const 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")
-  };
-};
-const getPublicKeyEthereum = secretKey => {
-  const scalar = secp256k1.utils.normPrivateKeyToScalar(secretKey);
-  return secp256k1.getPublicKey(scalar, false);
-};
-
-// Convert a path like "m/44'/501'/0'/0'" to an array of indexes
-const parseDerivationPath = path => {
-  if (!path.startsWith("m/")) throw new Error("Path must start with 'm/'");
-  return path.split("/").slice(1) // Remove 'm'
-  .map(p => {
-    if (!p.endsWith("'")) throw new Error("Only hardened derivation is supported");
-    return parseInt(p.slice(0, -1), 10) + 0x80000000; // Convert to hardened index
-  });
-};
-const deriveSolana = (seed, derivationPath) => {
-  // Generate master private key using SLIP-0010 (HMAC-SHA512 with "ed25519 seed")
-  let I = hmac(sha512, new TextEncoder().encode("ed25519 seed"), seed);
-  let secretKey = I.slice(0, 32);
-  let chainCode = I.slice(32);
-
-  // Iterate over the derivation path and apply hardened key derivation
-  for (const index of parseDerivationPath(derivationPath)) {
-    // HMAC-SHA512(Key = chainCode, Data = 0x00 || privateKey || index)
-    const data = new Uint8Array(1 + secretKey.length + 4);
-    data.set([0x00], 0);
-    data.set(secretKey, 1);
-    data.set(new Uint8Array([index >> 24 & 0xff, index >> 16 & 0xff, index >> 8 & 0xff, index & 0xff]), 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.getPublicKey(secretKey);
-};
-
-const deriveSr25519 = (seed, derivationPath) => {
-  const derivations = parseSubstrateDerivations(derivationPath);
-  const secretKey = derivations.reduce((secretKey, [type, chainCode]) => {
-    const deriveFn = type === "hard" ? HDKD.secretHard : HDKD.secretSoft;
-    const code = createChainCode(chainCode);
-    return deriveFn(secretKey, code, randomBytes);
-  }, secretFromSeed(seed));
-  const publicKey = getPublicKeySr25519(secretKey);
-  return {
-    type: "sr25519",
-    secretKey,
-    publicKey,
-    address: addressFromPublicKey(publicKey, "ss58")
-  };
-};
-const getPublicKeySr25519 = getPublicKey;
-
-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 entropy = mnemonicToEntropy(mnemonic);
-  const seed = await entropyToSeed(entropy, 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.decode(privateKey);
-      }
-    case "solana":
-      {
-        const bytes = secretKey.startsWith("[") ?
-        // JSON bytes array (ex: solflare)
-        Uint8Array.from(JSON.parse(secretKey)) :
-        // base58 encoded string (ex: phantom)
-        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");
-  }
-};
-
-// @dev: didn't find a reliable source of information on which characters are valid => assume it s valid if a keypair can be generated from it
-const isValidDerivationPath = async (derivationPath, curve) => {
-  try {
-    deriveKeypair(await getDevSeed(curve), derivationPath, curve);
-    return true;
-  } catch (err) {
-    return false;
-  }
-};
-
-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);
-};
-
-const 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);
-};
-
-export { DEV_MNEMONIC_ETHEREUM, DEV_MNEMONIC_POLKADOT, addressEncodingFromCurve, addressFromMnemonic, addressFromPublicKey, blake2b256, blake2b512, blake3, checksumEthereumAddress, decodeSs58Address, deriveKeypair, detectAddressEncoding, encodeAddressEthereum, encodeAddressSolana, encodeAddressSs58, encodeAnyAddress, encryptKemAead, entropyToMnemonic, entropyToSeed, fromBase58Check, fromBech32, fromBech32m, generateMnemonic, getAccountPlatformFromAddress, getAccountPlatformFromCurve, getAccountPlatformFromEncoding, getDevSeed, getPublicKeyFromSecret, getSafeHash, isAddressEqual, isAddressValid, isBase58CheckAddress, isBech32Address, isBech32mAddress, isBitcoinAddress, isEthereumAddress, isSolanaAddress, isSs58Address, isValidDerivationPath, isValidMnemonic, mnemonicToEntropy, normalizeAddress, parseSecretKey, pbkdf2, removeHexPrefix };