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

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/mnemonic/index.ts","../src/utils/exports.ts","../src/utils/pbkdf2.ts","../src/derivation/utils.ts","../src/derivation/deriveEcdsa.ts","../src/address/encoding/addressEncodingFromCurve.ts","../src/address/encoding/solana.ts","../src/address/encoding/bitcoin.ts","../src/address/encoding/ethereum.ts","../src/address/encoding/ss58.ts","../src/hashing/index.ts","../src/address/encoding/detectAddressEncoding.ts","../src/address/addressFromPublicKey.ts","../src/address/normalizeAddress.ts","../src/address/isAddressEqual.ts","../src/address/encodeAnyAddress.ts","../src/address/isAddressValid.ts","../src/derivation/common.ts","../src/derivation/deriveEd25519.ts","../src/derivation/deriveEthereum.ts","../src/derivation/deriveSolana.ts","../src/derivation/deriveSr25519.ts","../src/platform/index.ts","../src/encryption/encryptKemAead.ts"],"sourcesContent":["export * from \"./types\"\nexport * from \"./mnemonic\"\nexport * from \"./derivation\"\nexport * from \"./address\"\nexport * from \"./utils\"\nexport * from \"./platform\"\nexport * from \"./hashing\"\nexport * from \"./encryption\"\n","import {\n  entropyToMnemonic as entropyToMnemonicBip39,\n  generateMnemonic as generateMnemonicBip39,\n  mnemonicToEntropy as mnemonicToEntropyBip39,\n  validateMnemonic,\n} from \"@scure/bip39\"\nimport { wordlist } from \"@scure/bip39/wordlists/english\"\n\nimport type { KeypairCurve } from \"../types\"\nimport { pbkdf2 } from \"../utils\"\n\nexport const mnemonicToEntropy = (mnemonic: string) => {\n  return mnemonicToEntropyBip39(mnemonic, wordlist)\n}\n\nexport const entropyToMnemonic = (entropy: Uint8Array) => {\n  return entropyToMnemonicBip39(entropy, wordlist)\n}\n\nconst entropyToSeedSubstrate = async (entropy: Uint8Array, password?: string) =>\n  await pbkdf2(\n    \"SHA-512\",\n    entropy,\n    mnemonicPasswordToSalt(password ?? \"\"),\n    2048, // 2048 iterations\n    32, // 32 bytes (32 * 8 == 256 bits)\n  )\n\nconst entropyToSeedClassic = async (entropy: Uint8Array, password?: string) =>\n  await pbkdf2(\n    \"SHA-512\",\n    encodeNormalized(entropyToMnemonic(entropy)),\n    mnemonicPasswordToSalt(password ?? \"\"),\n    2048, // 2048 iterations\n    64, // 64 bytes (64 * 8 == 512 bits)\n  )\n\nconst mnemonicPasswordToSalt = (password: string) => encodeNormalized(`mnemonic${password}`)\n\n/** Normalizes a UTF-8 string using `NFKD` form, then encodes it into bytes */\nconst encodeNormalized = (utf8: string): Uint8Array =>\n  new TextEncoder().encode(utf8.normalize(\"NFKD\"))\n\ntype SeedDerivationType = \"substrate\" | \"classic\"\n\nconst getSeedDerivationType = (curve: KeypairCurve): SeedDerivationType => {\n  switch (curve) {\n    case \"sr25519\":\n    case \"ed25519\":\n    case \"ecdsa\":\n      return \"substrate\"\n    case \"ethereum\":\n    case \"solana\":\n      return \"classic\"\n    case \"bitcoin-ecdsa\":\n    case \"bitcoin-ed25519\":\n      throw new Error(\"seed derivation is not implemented for Bitcoin\")\n  }\n}\n\n// when deriving keys from a mnemonic, we usually dont want a password here.\n// a password provided here would be used as a 25th mnemonic word.\nexport const entropyToSeed = async (\n  entropy: Uint8Array,\n  curve: KeypairCurve,\n  password?: string,\n) => {\n  const type = getSeedDerivationType(curve)\n\n  switch (type) {\n    case \"classic\":\n      return await entropyToSeedClassic(entropy, password)\n    case \"substrate\":\n      return await entropyToSeedSubstrate(entropy, password)\n  }\n}\n\nexport const isValidMnemonic = (mnemonic: string) => {\n  return validateMnemonic(mnemonic, wordlist)\n}\n\nexport const generateMnemonic = (words: 12 | 24) => {\n  switch (words) {\n    case 12:\n      return generateMnemonicBip39(wordlist, 128)\n    case 24:\n      return generateMnemonicBip39(wordlist, 256)\n  }\n}\n\n// well-known mnemonic used by polkadot.js, can be checked on polkadot wiki\nexport const DEV_MNEMONIC_POLKADOT =\n  \"bottom drive obey lake curtain smoke basket hold race lonely fit walk\"\n\n// well-known phrase used by hardhat and anvil\nexport const DEV_MNEMONIC_ETHEREUM = \"test test test test test test test test test test test junk\"\n\n// keep dev seeds in cache as we will reuse them to validate multiple derivation paths\nconst DEV_SEED_CACHE = new Map<SeedDerivationType, Uint8Array>()\n\nexport const getDevSeed = async (curve: KeypairCurve) => {\n  const type = getSeedDerivationType(curve)\n\n  if (!DEV_SEED_CACHE.has(type)) {\n    switch (type) {\n      case \"classic\": {\n        const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM)\n        const seed = await entropyToSeedClassic(entropy) // 80ms\n        DEV_SEED_CACHE.set(type, seed)\n        break\n      }\n      case \"substrate\": {\n        const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT)\n        const seed = await entropyToSeedSubstrate(entropy) // 80ms\n        DEV_SEED_CACHE.set(type, seed)\n        break\n      }\n      default:\n        throw new Error(\"Unsupported derivation type\")\n    }\n  }\n\n  return DEV_SEED_CACHE.get(type)!\n}\n","export { base58, base64, hex, utf8 } from \"@scure/base\"\nexport { ed25519 } from \"@noble/curves/ed25519\"\n","export const pbkdf2 = async (\n  hash: \"SHA-256\" | \"SHA-512\",\n  entropy: Uint8Array,\n  salt: Uint8Array,\n  iterations: number,\n  outputLenBytes: number,\n) => {\n  // NOTE: react-native-quick-crypto (our `global.crypto` polyfill on Talisman Mobile) doesn't support `crypto.subtle.deriveKey`.\n  // But, we can work around this by using `crypto.subtle.deriveBits` and `crypto.subtle.importKey`, which when used together\n  // can provide the same functionality as `crypto.subtle.deriveKey`.\n  const keyMaterial = await crypto.subtle.importKey(\"raw\", entropy, \"PBKDF2\", false, [\"deriveBits\"])\n  const derivedBits = await crypto.subtle.deriveBits(\n    { name: \"PBKDF2\", salt, iterations, hash },\n    keyMaterial,\n    outputLenBytes * 8,\n  )\n  return new Uint8Array(derivedBits)\n}\n","import { base58, hex } from \"@scure/base\"\n\nimport { entropyToSeed, getDevSeed, mnemonicToEntropy } from \"../mnemonic\"\nimport { AccountPlatform, KeypairCurve } from \"../types\"\nimport { deriveEcdsa, getPublicKeyEcdsa } from \"./deriveEcdsa\"\nimport { deriveEd25519, getPublicKeyEd25519 } from \"./deriveEd25519\"\nimport { deriveEthereum, getPublicKeyEthereum } from \"./deriveEthereum\"\nimport { deriveSolana, getPublicKeySolana } from \"./deriveSolana\"\nimport { deriveSr25519, getPublicKeySr25519 } from \"./deriveSr25519\"\n\nexport const deriveKeypair = (seed: Uint8Array, derivationPath: string, curve: KeypairCurve) => {\n  switch (curve) {\n    case \"sr25519\":\n      return deriveSr25519(seed, derivationPath)\n    case \"ed25519\":\n      return deriveEd25519(seed, derivationPath)\n    case \"ecdsa\":\n      return deriveEcdsa(seed, derivationPath)\n    case \"bitcoin-ecdsa\":\n    case \"bitcoin-ed25519\":\n      throw new Error(\"deriveKeypair is not implemented for Bitcoin\")\n    case \"ethereum\":\n      return deriveEthereum(seed, derivationPath)\n    case \"solana\":\n      return deriveSolana(seed, derivationPath)\n  }\n}\n\nexport const getPublicKeyFromSecret = (secretKey: Uint8Array, curve: KeypairCurve): Uint8Array => {\n  switch (curve) {\n    case \"ecdsa\":\n      return getPublicKeyEcdsa(secretKey)\n    case \"ethereum\":\n      return getPublicKeyEthereum(secretKey)\n    case \"sr25519\":\n      return getPublicKeySr25519(secretKey)\n    case \"ed25519\":\n      return getPublicKeyEd25519(secretKey)\n    case \"bitcoin-ecdsa\":\n    case \"bitcoin-ed25519\":\n      throw new Error(\"getPublicKeyFromSecret is not implemented for Bitcoin\")\n    case \"solana\":\n      return getPublicKeySolana(secretKey)\n  }\n}\n\nexport const addressFromMnemonic = async (\n  mnemonic: string,\n  derivationPath: string,\n  curve: KeypairCurve,\n) => {\n  const entropy = mnemonicToEntropy(mnemonic)\n  const seed = await entropyToSeed(entropy, curve)\n  const { address } = deriveKeypair(seed, derivationPath, curve)\n  return address\n}\n\nexport const removeHexPrefix = (secretKey: string) => {\n  if (secretKey.startsWith(\"0x\")) return secretKey.slice(2)\n  return secretKey\n}\n\nexport const parseSecretKey = (secretKey: string, platform: AccountPlatform) => {\n  switch (platform) {\n    case \"ethereum\": {\n      const privateKey = removeHexPrefix(secretKey)\n      return hex.decode(privateKey)\n    }\n    case \"solana\": {\n      const bytes = secretKey.startsWith(\"[\")\n        ? // JSON bytes array (ex: solflare)\n          Uint8Array.from(JSON.parse(secretKey))\n        : // base58 encoded string (ex: phantom)\n          base58.decode(secretKey)\n\n      if (bytes.length === 64) {\n        const privateKey = bytes.slice(0, 32)\n        const publicKey = bytes.slice(32, 64)\n        const computedPublicKey = getPublicKeySolana(privateKey)\n        if (!publicKey.every((b, i) => b === computedPublicKey[i]))\n          throw new Error(\"Invalid Solana secret key: public key does not match\")\n        return privateKey\n      } else if (bytes.length === 32) return bytes\n\n      throw new Error(\"Invalid Solana secret key length\")\n    }\n\n    default:\n      throw new Error(\"Not implemented\")\n  }\n}\n\n// @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\nexport const isValidDerivationPath = async (derivationPath: string, curve: KeypairCurve) => {\n  try {\n    deriveKeypair(await getDevSeed(curve), derivationPath, curve)\n    return true\n  } catch (err) {\n    return false\n  }\n}\n","import { secp256k1 } from \"@noble/curves/secp256k1\"\n\nimport type { Keypair } from \"../types\"\nimport { addressFromPublicKey } from \"../address\"\nimport { deriveSubstrateSecretKey } from \"./common\"\n\nexport const deriveEcdsa = (seed: Uint8Array, derivationPath: string): Keypair => {\n  const secretKey = deriveSubstrateSecretKey(seed, derivationPath, \"Secp256k1HDKD\")\n\n  const publicKey = getPublicKeyEcdsa(secretKey)\n\n  return {\n    type: \"ecdsa\",\n    secretKey,\n    publicKey,\n    address: addressFromPublicKey(publicKey, \"ss58\"),\n  }\n}\n\nexport const getPublicKeyEcdsa = (secretKey: Uint8Array) => {\n  return secp256k1.getPublicKey(secretKey)\n}\n","import type { AddressEncoding, KeypairCurve } from \"../../types\"\n\n/** NOTE: Try not to use this too much, it will need to change */\nexport const addressEncodingFromCurve = (curve: KeypairCurve): AddressEncoding => {\n  switch (curve) {\n    case \"sr25519\":\n    case \"ed25519\":\n    case \"ecdsa\":\n      return \"ss58\"\n    case \"bitcoin-ecdsa\":\n    case \"bitcoin-ed25519\":\n      // NOTE: Bitcoin has multiple address formats, so this isn't necessarily correct\n      // The format MAY be bech32m, but it might also be bech32 or base58check.\n      // bech32m is the most recent format.\n      return \"bech32m\"\n    case \"ethereum\":\n      return \"ethereum\"\n    case \"solana\":\n      return \"base58solana\"\n  }\n}\n","import { base58 } from \"@scure/base\"\n\nexport const encodeAddressSolana = (publicKey: Uint8Array): string => {\n  if (publicKey.length !== 32)\n    throw new Error(\"Public key must be 32 bytes long for Solana base58 encoding\")\n  return base58.encode(publicKey)\n}\nexport function isSolanaAddress(address: string): boolean {\n  try {\n    const bytes = base58.decode(address)\n    return bytes.length === 32\n  } catch (error) {\n    return false\n  }\n}\n","import { bech32, bech32m } from \"bech32\"\nimport bs58check from \"bs58check\"\n\nexport const isBitcoinAddress = (address: string) =>\n  isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address)\n\nexport function isBech32mAddress(address: string) {\n  try {\n    fromBech32m(address)\n  } catch {\n    return false\n  }\n  return true\n}\n\nexport function isBech32Address(address: string) {\n  try {\n    fromBech32(address)\n  } catch {\n    return false\n  }\n  return true\n}\n\nexport function isBase58CheckAddress(address: string) {\n  try {\n    fromBase58Check(address)\n  } catch {\n    return false\n  }\n  return true\n}\n\n/**\n * Converts a Bech32m encoded address to its corresponding data representation.\n * @param address - The Bech32m encoded address.\n * @returns An object containing the version, prefix, and data of the address.\n * @throws {TypeError} If the address uses the wrong encoding.\n */\nexport function fromBech32m(address: string) {\n  const result = bech32m.decode(address)\n  const version = result.words[0]\n  if (version === 0) throw new TypeError(address + \" uses wrong encoding\")\n  const data = bech32m.fromWords(result.words.slice(1))\n  return {\n    version,\n    prefix: result.prefix,\n    data: Uint8Array.from(data),\n  }\n}\n\n/**\n * Converts a Bech32 encoded address to its corresponding data representation.\n * @param address - The Bech32 encoded address.\n * @returns An object containing the version, prefix, and data of the address.\n * @throws {TypeError} If the address uses the wrong encoding.\n */\nexport function fromBech32(address: string) {\n  const result = bech32.decode(address)\n  const version = result.words[0]\n  if (version !== 0) throw new TypeError(address + \" uses wrong encoding\")\n  const data = bech32.fromWords(result.words.slice(1))\n  return {\n    version,\n    prefix: result.prefix,\n    data: Uint8Array.from(data),\n  }\n}\n\n/**\n * Decodes a base58check encoded Bitcoin address and returns the version and hash.\n *\n * @param address - The base58check encoded Bitcoin address to decode.\n * @returns An object containing the version and hash of the decoded address.\n * @throws {TypeError} If the address is too short or too long.\n */\nexport function fromBase58Check(address: string) {\n  const payload = bs58check.decode(address)\n  if (payload.length < 21) throw new TypeError(address + \" is too short\")\n  if (payload.length > 21) throw new TypeError(address + \" is too long\")\n  function readUInt8(buffer: Uint8Array, offset: number) {\n    if (offset + 1 > buffer.length) {\n      throw new Error(\"Offset is outside the bounds of Uint8Array\")\n    }\n    const buf = Buffer.from(buffer)\n    return buf.readUInt8(offset)\n  }\n  const version = readUInt8(payload, 0)\n  const hash = payload.slice(1)\n  return { version, hash }\n}\n","import { keccak_256 } from \"@noble/hashes/sha3\"\nimport { bytesToHex } from \"@noble/hashes/utils\"\n\n/**\n * Encodes a public key using H160 encoding with Ethereum checksum.\n */\nexport const encodeAddressEthereum = (publicKey: Uint8Array): `0x${string}` => {\n  // Ensure the public key is in uncompressed format (starts with 0x04)\n  if (publicKey[0] !== 0x04) throw new Error(\"Invalid public key format\")\n\n  // Remove the prefix (0x04)\n  const publicKeyWithoutPrefix = publicKey.slice(1)\n\n  // Apply Keccak-256 hashing to the public key\n  const hash = keccak_256(publicKeyWithoutPrefix)\n\n  // Take the last 20 bytes of the hash to get the Ethereum address\n  const address = hash.slice(-20)\n\n  // Apply checksum\n  return checksumEthereumAddress(`0x${bytesToHex(address)}`)\n}\n\nexport const checksumEthereumAddress = (address: string): `0x${string}` => {\n  const addr = address.toLowerCase().replace(/^0x/, \"\")\n  const hash = keccak_256(new TextEncoder().encode(addr))\n  const hashHex = bytesToHex(hash)\n\n  const checksum = addr\n    .split(\"\")\n    .map((char, i) => (parseInt(hashHex[i], 16) >= 8 ? char.toUpperCase() : char))\n    .join(\"\")\n\n  return `0x${checksum}`\n}\n\nexport function isEthereumAddress(address: string): address is `0x${string}` {\n  return /^0x[a-fA-F0-9]{40}$/.test(address)\n}\n\n// Note: public key cannot be retrieved from an address, because address is hashed from only the last 20 bytes of the pk\n","import { base58 } from \"@scure/base\"\n\nimport { blake2b256, blake2b512 } from \"../../hashing\"\n\n// Inspired from MIT licensed @polkadot-labs/hdkd-helpers\n// https://github.com/polkadot-labs/hdkd/blob/3ef6e02827212d934b59a4e566d8aa61d3ba7b27/packages/hdkd-helpers/src/accountId.ts#L3\n\nconst VALID_PUBLICKEY_LENGTHS = [32, 33]\nconst accountId = (publicKey: Uint8Array) => {\n  if (!VALID_PUBLICKEY_LENGTHS.includes(publicKey.length)) throw new Error(\"Invalid publicKey\")\n  return publicKey.length === 33 ? blake2b256(publicKey) : publicKey\n}\n\nconst SS58PRE = /* @__PURE__ */ new TextEncoder().encode(\"SS58PRE\")\nconst CHECKSUM_LENGTH = 2\n\nconst VALID_PAYLOAD_LENGTHS = [32, 33]\nconst ss58Encode = (payload: Uint8Array, prefix = 42) => {\n  if (!VALID_PAYLOAD_LENGTHS.includes(payload.length)) throw new Error(\"Invalid payload\")\n\n  const prefixBytes =\n    prefix < 64\n      ? Uint8Array.of(prefix)\n      : Uint8Array.of(\n          ((prefix & 0b0000_0000_1111_1100) >> 2) | 0b0100_0000,\n          (prefix >> 8) | ((prefix & 0b0000_0000_0000_0011) << 6),\n        )\n  const checksum = blake2b512(Uint8Array.of(...SS58PRE, ...prefixBytes, ...payload)).subarray(\n    0,\n    CHECKSUM_LENGTH,\n  )\n  return base58.encode(Uint8Array.of(...prefixBytes, ...payload, ...checksum))\n}\n\nconst VALID_ADDRESS_LENGTHS = [35, 36, 37]\nexport const decodeSs58Address = (addressStr: string): [publicKey: Uint8Array, prefix: number] => {\n  const address = base58.decode(addressStr)\n  if (!VALID_ADDRESS_LENGTHS.includes(address.length)) throw new Error(\"Invalid address length\")\n\n  const addressChecksum = address.subarray(address.length - CHECKSUM_LENGTH)\n  const checksum = blake2b512(\n    Uint8Array.of(...SS58PRE, ...address.subarray(0, address.length - CHECKSUM_LENGTH)),\n  ).subarray(0, CHECKSUM_LENGTH)\n  if (addressChecksum[0] !== checksum[0] || addressChecksum[1] !== checksum[1])\n    throw new Error(\"Invalid checksum\")\n\n  const prefixLength = address[0]! & 0b0100_0000 ? 2 : 1\n  const prefix: number =\n    prefixLength === 1\n      ? address[0]!\n      : ((address[0]! & 0b0011_1111) << 2) | (address[1]! >> 6) | ((address[1]! & 0b0011_1111) << 8)\n  const publicKey = address.slice(prefixLength, address.length - CHECKSUM_LENGTH)\n  return [publicKey, prefix]\n}\n\nexport const encodeAddressSs58 = (publicKey: Uint8Array | string, prefix = 42) => {\n  if (typeof publicKey === \"string\") [publicKey] = decodeSs58Address(publicKey)\n  return ss58Encode(accountId(publicKey), prefix)\n}\n\nexport function isSs58Address(address: string): boolean {\n  try {\n    decodeSs58Address(address)\n    return true\n  } catch (error) {\n    return false\n  }\n}\n","import { blake2b } from \"@noble/hashes/blake2b\"\nimport { blake3 as blake3Hasher } from \"@noble/hashes/blake3\"\nimport { base58 } from \"@scure/base\"\n\nexport const blake3 = blake3Hasher\n\nexport const blake2b256 = (msg: Uint8Array) => blake2b(msg, { dkLen: 32 })\nexport const blake2b512 = (msg: Uint8Array) => blake2b(msg, { dkLen: 64 })\n\nexport const getSafeHash = (bytes: Uint8Array) => {\n  // cryptographically secure one way hash\n  // outputs 44 characters without special characters\n  return base58.encode(blake3Hasher(bytes))\n}\n","import type { AddressEncoding } from \"../../types\"\nimport { isBase58CheckAddress, isBech32Address, isBech32mAddress } from \"./bitcoin\"\nimport { isEthereumAddress } from \"./ethereum\"\nimport { isSolanaAddress } from \"./solana\"\nimport { isSs58Address } from \"./ss58\"\n\nconst CACHE = new Map<string, AddressEncoding>()\n\nconst detectAddressEncodingInner = (address: string): AddressEncoding => {\n  if (isEthereumAddress(address)) return \"ethereum\"\n  if (isSs58Address(address)) return \"ss58\"\n  if (isSolanaAddress(address)) return \"base58solana\"\n  if (isBech32mAddress(address)) return \"bech32m\"\n  if (isBech32Address(address)) return \"bech32\"\n  if (isBase58CheckAddress(address)) return \"base58check\"\n\n  throw new Error(`Unknown address encoding`)\n}\nexport const detectAddressEncoding = (address: string): AddressEncoding => {\n  if (!CACHE.has(address)) CACHE.set(address, detectAddressEncodingInner(address))\n  return CACHE.get(address)!\n}\n","import type { AddressEncoding } from \"../types\"\nimport { encodeAddressEthereum, encodeAddressSolana, encodeAddressSs58 } from \"./encoding\"\n\nexport type EncodeAddressOptions = {\n  ss58Prefix?: number\n}\n\nexport const addressFromPublicKey = (\n  publicKey: Uint8Array,\n  encoding: AddressEncoding,\n  options?: EncodeAddressOptions,\n): string => {\n  switch (encoding) {\n    case \"ss58\":\n      return encodeAddressSs58(publicKey, options?.ss58Prefix)\n    case \"ethereum\":\n      return encodeAddressEthereum(publicKey)\n    case \"base58solana\":\n      return encodeAddressSolana(publicKey)\n    case \"bech32m\":\n    case \"bech32\":\n    case \"base58check\":\n      throw new Error(\"addressFromPublicKey is not implemented for Bitcoin\")\n  }\n}\n","import {\n  checksumEthereumAddress,\n  decodeSs58Address,\n  detectAddressEncoding,\n  encodeAddressSs58,\n} from \"./encoding\"\n\nconst CACHE = new Map<string, string>()\n\n// Normalize an address in a way that it can be compared to other addresses that have also been normalized\nexport const normalizeAddress = (address: string) => {\n  try {\n    if (!CACHE.has(address)) CACHE.set(address, normalizeAnyAddress(address))\n    return CACHE.get(address)!\n  } catch (cause) {\n    throw new Error(`Unable to normalize address: ${address}`, { cause })\n  }\n}\n\nconst normalizeAnyAddress = (address: string) => {\n  switch (detectAddressEncoding(address)) {\n    case \"ethereum\":\n      return checksumEthereumAddress(address)\n    case \"bech32m\":\n    case \"bech32\":\n    case \"base58check\":\n    case \"base58solana\":\n      return address\n    case \"ss58\": {\n      const [pk] = decodeSs58Address(address)\n      return encodeAddressSs58(pk, 42)\n    }\n  }\n}\n","import { normalizeAddress } from \"./normalizeAddress\"\n\nexport const isAddressEqual = (address1: string, address2: string) => {\n  try {\n    return normalizeAddress(address1) === normalizeAddress(address2)\n  } catch (err) {\n    // if normalization fails, assume the addresses are not equal\n    return false\n  }\n}\n","import { decodeSs58Address, detectAddressEncoding, encodeAddressSs58 } from \"./encoding\"\nimport { normalizeAddress } from \"./normalizeAddress\"\n\ntype EncodeAddressOptions = {\n  ss58Format?: number | undefined\n}\n\nexport const encodeAnyAddress = (address: string, options?: EncodeAddressOptions) => {\n  // this leverages cache\n  const encoding = detectAddressEncoding(address)\n\n  // this does NOT leverage cache\n  if (encoding === \"ss58\" && options?.ss58Format !== undefined) {\n    const [publicKey] = decodeSs58Address(address)\n    return encodeAddressSs58(publicKey, options?.ss58Format ?? 42)\n  }\n\n  // this leverages cache\n  return normalizeAddress(address)\n}\n","import { detectAddressEncoding } from \"./encoding\"\n\nexport const isAddressValid = (address: string): boolean => {\n  try {\n    detectAddressEncoding(address)\n    return true\n  } catch {\n    return false\n  }\n}\n","import { Bytes, str, Tuple, u32 } from \"scale-ts\"\n\nimport { blake2b256 } from \"../hashing\"\n\n// Inspired from MIT licensed @polkadot-labs/hdkd helpers\n// https://github.com/polkadot-labs/hdkd/blob/3ef6e02827212d934b59a4e566d8aa61d3ba7b27/packages/hdkd-helpers/src/parseDerivations.ts#L1\n\nconst DERIVATION_RE = /(\\/{1,2})(\\w+)/g\n\ntype DerivationDescriptor = [type: \"hard\" | \"soft\", code: string]\n\nexport const parseSubstrateDerivations = (derivationsStr: string): DerivationDescriptor[] => {\n  const derivations = [] as DerivationDescriptor[]\n  if (derivations)\n    for (const [_, type, code] of derivationsStr.matchAll(DERIVATION_RE)) {\n      derivations.push([type === \"//\" ? \"hard\" : \"soft\", code!])\n    }\n  return derivations\n}\n\nexport const createChainCode = (code: string) => {\n  const chainCode = new Uint8Array(32)\n  chainCode.set(Number.isNaN(+code) ? str.enc(code) : u32.enc(+code))\n  return chainCode\n}\n\nconst derivationCodec = /* @__PURE__ */ Tuple(str, Bytes(32), Bytes(32))\nconst createSubstrateDeriveFn = (prefix: string) => (seed: Uint8Array, chainCode: Uint8Array) =>\n  blake2b256(derivationCodec.enc([prefix, seed, chainCode]))\n\nexport const deriveSubstrateSecretKey = (\n  seed: Uint8Array,\n  derivationPath: string,\n  prefix: string,\n) => {\n  const derivations = parseSubstrateDerivations(derivationPath)\n  const derive = createSubstrateDeriveFn(prefix)\n\n  return derivations.reduce((seed, [type, chainCode]) => {\n    const code = createChainCode(chainCode)\n    if (type === \"soft\") throw new Error(\"Soft derivations are not supported\")\n    return derive(seed, code)\n  }, seed)\n}\n","import { ed25519 } from \"@noble/curves/ed25519\"\n\nimport type { Keypair } from \"../types\"\nimport { addressFromPublicKey } from \"../address\"\nimport { deriveSubstrateSecretKey } from \"./common\"\n\nexport const deriveEd25519 = (seed: Uint8Array, derivationPath: string): Keypair => {\n  const secretKey = deriveSubstrateSecretKey(seed, derivationPath, \"Ed25519HDKD\")\n\n  const publicKey = getPublicKeyEd25519(secretKey)\n\n  return {\n    type: \"ed25519\",\n    secretKey,\n    publicKey,\n    address: addressFromPublicKey(publicKey, \"ss58\"),\n  }\n}\n\nexport const getPublicKeyEd25519 = (secretKey: Uint8Array) => {\n  // When importing ed25519 polkadot-js accounts via json, which we do inside of `packages/extension-core/src/domains/keyring/getSecretKeyFromPjsJson.ts`,\n  // the secretKey we produce is 64 bytes in length.\n  //\n  // When using the ed25519 curve to derive a publicKey for this 64 bytes privateKey, we should only take the first 32 bytes:\n  // - https://github.com/paulmillr/noble-curves/issues/53#issuecomment-1577362759\n  // - https://github.com/paulmillr/noble-curves/discussions/33#discussioncomment-5685971\n  // - https://github.com/paulmillr/noble-curves/pull/54\n  // - https://github.com/paulmillr/noble-curves/issues/88\n  //\n  // When you compare the ed25519 publicKey of a given account produced by this function to the publicKey produced by\n  // polkadot-js, you will find that they are the same as eachother.\n  if (secretKey.length === 64) {\n    const [privateComponent, publicComponent] = [secretKey.slice(0, 32), secretKey.slice(32)]\n    const publicKey = ed25519.getPublicKey(privateComponent)\n\n    // 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.\n    //\n    // In this scenario, we assume the creator of the secretKey has given us an array of bytes which equals `[...privateKey, ...publicKey]`.\n    //\n    // 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.\n    //\n    // 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`.\n    // 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.\n    if (!isUint8ArrayEq(publicComponent, publicKey)) return ed25519.getPublicKey(secretKey)\n\n    return publicKey\n  }\n\n  return ed25519.getPublicKey(secretKey)\n}\n\n/** If a is identical to b, this function returns true, otherwise it returns false */\nconst isUint8ArrayEq = (a: Uint8Array, b: Uint8Array) =>\n  a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true\n","import { secp256k1 } from \"@noble/curves/secp256k1\"\nimport { HDKey } from \"@scure/bip32\"\n\nimport type { Keypair } from \"../types\"\nimport { addressFromPublicKey } from \"../address\"\n\nexport const deriveEthereum = (seed: Uint8Array, derivationPath: string): Keypair => {\n  const hdkey = HDKey.fromMasterSeed(seed)\n\n  const childKey = hdkey.derive(derivationPath)\n  if (!childKey.privateKey) throw new Error(\"Invalid derivation path\")\n  const secretKey = new Uint8Array(childKey.privateKey)\n\n  const publicKey = getPublicKeyEthereum(secretKey)\n\n  return {\n    type: \"ethereum\",\n    secretKey,\n    publicKey,\n    address: addressFromPublicKey(publicKey, \"ethereum\"),\n  }\n}\n\nexport const getPublicKeyEthereum = (secretKey: Uint8Array) => {\n  const scalar = secp256k1.utils.normPrivateKeyToScalar(secretKey)\n  return secp256k1.getPublicKey(scalar, false)\n}\n","import { ed25519 } from \"@noble/curves/ed25519\"\nimport { hmac } from \"@noble/hashes/hmac\"\nimport { sha512 } from \"@noble/hashes/sha512\"\n\nimport type { Keypair } from \"../types\"\nimport { addressFromPublicKey } from \"../address\"\n\n// Convert a path like \"m/44'/501'/0'/0'\" to an array of indexes\nconst parseDerivationPath = (path: string): number[] => {\n  if (!path.startsWith(\"m/\")) throw new Error(\"Path must start with 'm/'\")\n  return path\n    .split(\"/\")\n    .slice(1) // Remove 'm'\n    .map((p) => {\n      if (!p.endsWith(\"'\")) throw new Error(\"Only hardened derivation is supported\")\n      return parseInt(p.slice(0, -1), 10) + 0x80000000 // Convert to hardened index\n    })\n}\n\nexport const deriveSolana = (seed: Uint8Array, derivationPath: string): Keypair => {\n  // Generate master private key using SLIP-0010 (HMAC-SHA512 with \"ed25519 seed\")\n  let I = hmac(sha512, new TextEncoder().encode(\"ed25519 seed\"), seed)\n  let secretKey = I.slice(0, 32)\n  let chainCode = I.slice(32)\n\n  // Iterate over the derivation path and apply hardened key derivation\n  for (const index of parseDerivationPath(derivationPath)) {\n    // HMAC-SHA512(Key = chainCode, Data = 0x00 || privateKey || index)\n    const data = new Uint8Array(1 + secretKey.length + 4)\n    data.set([0x00], 0)\n    data.set(secretKey, 1)\n    data.set(\n      new Uint8Array([\n        (index >> 24) & 0xff,\n        (index >> 16) & 0xff,\n        (index >> 8) & 0xff,\n        index & 0xff,\n      ]),\n      1 + secretKey.length,\n    )\n\n    I = hmac(sha512, chainCode, data)\n    secretKey = I.slice(0, 32)\n    chainCode = I.slice(32)\n  }\n\n  const publicKey = getPublicKeySolana(secretKey)\n\n  return {\n    type: \"solana\",\n    secretKey,\n    publicKey,\n    address: addressFromPublicKey(publicKey, \"base58solana\"),\n  }\n}\n\nexport const getPublicKeySolana = (secretKey: Uint8Array) => {\n  return ed25519.getPublicKey(secretKey)\n}\n","import { randomBytes } from \"@noble/hashes/utils\"\nimport { getPublicKey, HDKD, secretFromSeed } from \"micro-sr25519\"\n\nimport type { Keypair } from \"../types\"\nimport { addressFromPublicKey } from \"../address\"\nimport { createChainCode, parseSubstrateDerivations } from \"./common\"\n\nexport const deriveSr25519 = (seed: Uint8Array, derivationPath: string): Keypair => {\n  const derivations = parseSubstrateDerivations(derivationPath)\n\n  const secretKey = derivations.reduce((secretKey, [type, chainCode]) => {\n    const deriveFn = type === \"hard\" ? HDKD.secretHard : HDKD.secretSoft\n    const code = createChainCode(chainCode)\n    return deriveFn(secretKey, code, randomBytes)\n  }, secretFromSeed(seed))\n\n  const publicKey = getPublicKeySr25519(secretKey)\n  return {\n    type: \"sr25519\",\n    secretKey,\n    publicKey,\n    address: addressFromPublicKey(publicKey, \"ss58\"),\n  }\n}\n\nexport const getPublicKeySr25519 = getPublicKey\n","import { detectAddressEncoding } from \"../address\"\nimport { AccountPlatform, AddressEncoding, KeypairCurve } from \"../types\"\n\nexport const getAccountPlatformFromCurve = (curve: KeypairCurve): AccountPlatform => {\n  switch (curve) {\n    case \"sr25519\":\n    case \"ed25519\":\n    case \"ecdsa\":\n      return \"polkadot\"\n    case \"ethereum\":\n      return \"ethereum\"\n    case \"bitcoin-ecdsa\":\n    case \"bitcoin-ed25519\":\n      return \"bitcoin\"\n    case \"solana\":\n      return \"solana\"\n  }\n}\n\nexport const getAccountPlatformFromEncoding = (encoding: AddressEncoding): AccountPlatform => {\n  switch (encoding) {\n    case \"ss58\":\n      return \"polkadot\"\n    case \"ethereum\":\n      return \"ethereum\"\n    case \"bech32m\":\n    case \"bech32\":\n    case \"base58check\":\n      return \"bitcoin\"\n    case \"base58solana\":\n      return \"solana\"\n  }\n}\n\nexport const getAccountPlatformFromAddress = (address: string): AccountPlatform => {\n  const encoding = detectAddressEncoding(address)\n  return getAccountPlatformFromEncoding(encoding)\n}\n","import { xchacha20poly1305 } from \"@noble/ciphers/chacha.js\"\nimport { concatBytes } from \"@noble/ciphers/utils.js\"\nimport { MlKem768 } from \"mlkem\"\n\nexport const encryptKemAead = async (publicKey: Uint8Array, plaintext: Uint8Array) => {\n  const kem = new MlKem768()\n  const [kemCt, sharedSecret] = await kem.encap(publicKey)\n\n  if (sharedSecret.length !== 32) {\n    throw new Error(`Expected 32-byte shared secret, got ${sharedSecret.length}`)\n  }\n\n  const nonce = crypto.getRandomValues(new Uint8Array(24))\n\n  const aead = xchacha20poly1305(sharedSecret, nonce)\n  const aeadCt = aead.encrypt(plaintext)\n\n  const kemLen = new Uint8Array(2)\n  new DataView(kemLen.buffer).setUint16(0, kemCt.length, true)\n\n  return concatBytes(kemLen, kemCt, nonce, aeadCt)\n}\n"],"mappings":"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","names":["mnemonicToEntropyBip39","entropyToMnemonicBip39","utf8","generateMnemonicBip39","import_base","import_base","bs58check","import_utils","import_base","import_base","blake3Hasher","CACHE","seed","import_ed25519","import_secp256k1","import_ed25519","import_utils","secretKey","import_utils"]}