{"version":3,"file":"index.mjs","names":["base58","blake3Hasher","base58","base58","CACHE","ed25519","mnemonicToEntropyBip39","entropyToMnemonicBip39","generateMnemonicBip39","ed25519","hex","base58","base64","sr25519Sign","ed25519"],"sources":["../src/address/encoding/addressEncodingFromCurve.ts","../src/address/encoding/bitcoin.ts","../src/address/encoding/ethereum.ts","../src/address/encoding/solana.ts","../src/hashing/index.ts","../src/address/encoding/ss58.ts","../src/address/encoding/detectAddressEncoding.ts","../src/address/addressFromPublicKey.ts","../src/address/normalizeAddress.ts","../src/address/encodeAnyAddress.ts","../src/address/frontierEvmMirror.ts","../src/address/isAddressEqual.ts","../src/address/isAddressValid.ts","../src/derivation/deriveSolana.ts","../src/utils/pbkdf2.ts","../src/mnemonic/index.ts","../src/derivation/common.ts","../src/derivation/deriveEcdsa.ts","../src/derivation/deriveEd25519.ts","../src/derivation/deriveEthereum.ts","../src/derivation/deriveSr25519.ts","../src/derivation/utils.ts","../src/encryption/encryptKemAead.ts","../src/keystore/index.ts","../src/platform/index.ts","../src/signing/index.ts"],"sourcesContent":["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 { 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    return buffer[offset]\n  }\n  const version = readUInt8(payload, 0)\n  const hash = payload.slice(1)\n  return { version, hash }\n}\n","import { secp256k1 } from \"@noble/curves/secp256k1.js\"\nimport { keccak_256 } from \"@noble/hashes/sha3.js\"\nimport { bytesToHex } from \"@noble/hashes/utils.js\"\n\n/**\n * Encodes a public key using H160 encoding with Ethereum checksum.\n * Accepts both uncompressed (65 bytes) and compressed (33 bytes) public keys -\n * polkadot-js keystores store the compressed form as the account address.\n */\nexport const encodeAddressEthereum = (publicKey: Uint8Array): `0x${string}` => {\n  if (publicKey.length === 33 && (publicKey[0] === 0x02 || publicKey[0] === 0x03))\n    publicKey = secp256k1.Point.fromBytes(publicKey).toBytes(false)\n\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 { ed25519 } from \"@noble/curves/ed25519.js\"\nimport { 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 {\n    return false\n  }\n}\n\n/**\n * Whether the address is a valid ed25519 public key (on-curve).\n *\n * Program-derived addresses (PDAs) are off-curve by construction: no private key can exist\n * for them, so a regular wallet cannot recover tokens sent to an account they own.\n */\nexport function isOnCurveSolanaAddress(address: string): boolean {\n  try {\n    ed25519.Point.fromBytes(base58.decode(address))\n    return true\n  } catch {\n    return false\n  }\n}\n","import { blake2b } from \"@noble/hashes/blake2.js\"\nimport { blake3 as blake3Hasher } from \"@noble/hashes/blake3.js\"\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 { 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 = (\n  addressStr: string,\n  // polkadot-js keyring decodes keystore addresses with ignoreChecksum=true, replicate when needed\n  ignoreChecksum = false\n): [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 (!ignoreChecksum && (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 {\n    return false\n  }\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 { 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 { bytesToHex, hexToBytes } from \"@noble/hashes/utils.js\"\n\nimport { blake2b256 } from \"../hashing\"\nimport { decodeSs58Address, encodeAddressSs58, isEthereumAddress } from \"./encoding\"\n\n// Frontier pallet_evm HashedAddressMapping<BlakeTwo256>, the mapper of AccountId32 Frontier chains\n// (Bittensor, Astar): blake2b-256(\"evm:\" ++ h160), no length prefix. AccountId20 Frontier chains\n// (Moonbeam) use IdentityAddressMapping and need no conversion. Polkadot Asset Hub uses\n// pallet_revive AccountId32Mapper (h160 ++ 0xEE * 12), which is a different scheme.\nconst EVM_PREFIX = /* @__PURE__ */ new TextEncoder().encode(\"evm:\")\n\nexport const frontierH160ToAccountId32 = (h160: string): Uint8Array => {\n  if (!isEthereumAddress(h160)) throw new Error(\"Invalid H160 address\")\n\n  const data = new Uint8Array(EVM_PREFIX.length + 20)\n  data.set(EVM_PREFIX, 0)\n  data.set(hexToBytes(h160.slice(2).toLowerCase()), EVM_PREFIX.length)\n\n  return blake2b256(data)\n}\n\nexport const frontierH160ToSs58Mirror = (h160: string, ss58Prefix = 42): string =>\n  encodeAddressSs58(frontierH160ToAccountId32(h160), ss58Prefix)\n\nexport const frontierSs58ToPublicKeyHex = (address: string): `0x${string}` => {\n  const [publicKey] = decodeSs58Address(address)\n  if (publicKey.length !== 32) throw new Error(\"Expected a 32-byte public key\")\n  return `0x${bytesToHex(publicKey)}`\n}\n","import { normalizeAddress } from \"./normalizeAddress\"\n\nexport const isAddressEqual = (address1: string, address2: string) => {\n  try {\n    return normalizeAddress(address1) === normalizeAddress(address2)\n  } catch {\n    // if normalization fails, assume the addresses are not equal\n    return false\n  }\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 { ed25519 } from \"@noble/curves/ed25519.js\"\nimport { hmac } from \"@noble/hashes/hmac.js\"\nimport { sha512 } from \"@noble/hashes/sha2.js\"\nimport { addressFromPublicKey } from \"../address\"\nimport type { Keypair } from \"../types\"\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","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(\n    \"raw\",\n    entropy as Uint8Array<ArrayBuffer>,\n    \"PBKDF2\",\n    false,\n    [\"deriveBits\"]\n  )\n  const derivedBits = await crypto.subtle.deriveBits(\n    { name: \"PBKDF2\", salt: salt as Uint8Array<ArrayBuffer>, iterations, hash },\n    keyMaterial,\n    outputLenBytes * 8\n  )\n  return new Uint8Array(derivedBits)\n}\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.js\"\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","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 { secp256k1 } from \"@noble/curves/secp256k1.js\"\nimport { addressFromPublicKey } from \"../address\"\nimport type { Keypair } from \"../types\"\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 { ed25519 } from \"@noble/curves/ed25519.js\"\nimport { addressFromPublicKey } from \"../address\"\nimport type { Keypair } from \"../types\"\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 `apps/extension/src/core/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  // biome-ignore lint/complexity/noUselessTernary: legacy\n  a.length !== b.length || a.some((v, i) => v !== b[i]) ? false : true\n","import { secp256k1 } from \"@noble/curves/secp256k1.js\"\nimport { HDKey } from \"@scure/bip32\"\nimport { addressFromPublicKey } from \"../address\"\nimport type { Keypair } from \"../types\"\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  // noble v2 removed `utils.normPrivateKeyToScalar`; getPublicKey accepts the raw private-key\n  // bytes directly and applies the same normalization internally → byte-identical pubkey.\n  return secp256k1.getPublicKey(secretKey, false)\n}\n","import { getPublicKey, HDKD, secretFromSeed } from \"@scure/sr25519\"\nimport { addressFromPublicKey } from \"../address\"\nimport type { Keypair } from \"../types\"\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<Uint8Array>((secretKey, [type, chainCode]) => {\n    const code = createChainCode(chainCode)\n    // @scure/sr25519's HDKD changed `secretSoft`'s 3rd arg from an RNG function (micro-sr25519)\n    // to an optional 32-byte `random`; `secretHard` takes only (secretKey, chainCode). Omit the\n    // random arg — HDKD derivation output is deterministic regardless of it.\n    return type === \"hard\" ? HDKD.secretHard(secretKey, code) : HDKD.secretSoft(secretKey, code)\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 { base58, hex } from \"@scure/base\"\n\nimport { entropyToSeed, getDevSeed, mnemonicToEntropy } from \"../mnemonic\"\nimport type { 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 {\n    return false\n  }\n}\n","import { xchacha20poly1305 } from \"@noble/ciphers/chacha.js\"\nimport { concatBytes } from \"@noble/ciphers/utils.js\"\nimport { MlKem768 } from \"mlkem\"\n\n/**\n * Encrypts plaintext using ML-KEM-768 + XChaCha20-Poly1305 (KEM-AEAD).\n *\n * Wire format (subtensor pallet-shield v2):\n *   key_hash (16 bytes) || kem_len (2 bytes LE) || kem_ct (variable) || nonce (24 bytes) || aead_ct (variable)\n *\n * @param keyHash   16-byte xxhash128 of the public key (caller must compute, e.g. via Twox128)\n * @param publicKey ML-KEM-768 encapsulation key bytes\n * @param plaintext Data to encrypt (typically a signed extrinsic)\n */\nexport const encryptKemAead = async (\n  keyHash: Uint8Array,\n  publicKey: Uint8Array,\n  plaintext: Uint8Array\n) => {\n  if (keyHash.length !== 16) {\n    throw new Error(`Expected 16-byte keyHash, got ${keyHash.length}`)\n  }\n\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(keyHash, kemLen, kemCt, nonce, aeadCt)\n}\n","import { xsalsa20poly1305 } from \"@noble/ciphers/salsa.js\"\nimport { scrypt } from \"@noble/hashes/scrypt.js\"\nimport { base64 } from \"@scure/base\"\n\n/**\n * polkadot-js encrypted keystore JSON support (scrypt + xsalsa20-poly1305), byte-compatible\n * with `@polkadot/util-crypto` `jsonEncrypt`/`jsonDecrypt`.\n *\n * Layout of the base64 `encoded` blob:\n *   salt(32) ++ N(u32 LE) ++ p(u32 LE) ++ r(u32 LE) ++ nonce(24) ++ ciphertext\n */\n\nconst SALT_LENGTH = 32\nconst SCRYPT_PARAMS_LENGTH = 12\nconst NONCE_LENGTH = 24\n\n// scrypt param combos accepted by polkadot-js (scryptFromU8a ALLOWED_PARAMS) - includes\n// historical defaults (e.g. N=1<<15) so old exports remain importable; anything else is rejected\nconst ALLOWED_SCRYPT_PARAMS = [\n  { N: 1 << 13, p: 10, r: 8 },\n  { N: 1 << 14, p: 5, r: 8 },\n  { N: 1 << 15, p: 3, r: 8 },\n  { N: 1 << 15, p: 1, r: 8 },\n  { N: 1 << 16, p: 2, r: 8 },\n  { N: 1 << 17, p: 1, r: 8 },\n]\n\n// current polkadot-js scrypt defaults, used for encryption\nconst SCRYPT_N = 1 << 17\nconst SCRYPT_P = 1\nconst SCRYPT_R = 8\n\nexport type PjsKeystoreEncoding = {\n  content: string[]\n  type: string[]\n  version: string\n}\n\nexport type PjsKeystore = {\n  encoded: string\n  encoding: PjsKeystoreEncoding\n}\n\nconst readU32LE = (bytes: Uint8Array, offset: number) =>\n  bytes[offset] |\n  (bytes[offset + 1] << 8) |\n  (bytes[offset + 2] << 16) |\n  ((bytes[offset + 3] << 24) >>> 0)\n\nconst writeU32LE = (value: number) =>\n  new Uint8Array([value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff])\n\nconst deriveKey = (\n  password: string,\n  salt: Uint8Array,\n  params: { N: number; p: number; r: number }\n): Uint8Array =>\n  scrypt(new TextEncoder().encode(password), salt, { ...params, dkLen: 64 }).subarray(0, 32)\n\n/** Decrypts a polkadot-js encrypted keystore (`jsonDecrypt` equivalent) */\nexport const decryptPjsKeystore = (\n  { encoded, encoding }: PjsKeystore,\n  password: string\n): Uint8Array => {\n  if (!encoded) throw new Error(\"No encrypted data available to decode\")\n\n  const bytes = base64.decode(encoded)\n\n  // unencrypted keystores (e.g. in-memory transfers) pass their payload through as-is\n  if (!encoding.type.includes(\"xsalsa20-poly1305\")) {\n    if (encoding.type.includes(\"none\")) return bytes\n    throw new Error(`Unsupported keystore encoding: ${encoding.type.join(\"/\")}`)\n  }\n\n  let offset = 0\n  let key: Uint8Array\n  if (encoding.type.includes(\"scrypt\")) {\n    const salt = bytes.subarray(0, SALT_LENGTH)\n    const N = readU32LE(bytes, SALT_LENGTH)\n    const p = readU32LE(bytes, SALT_LENGTH + 4)\n    const r = readU32LE(bytes, SALT_LENGTH + 8)\n    // just a safeguard against DoS by malicious params, same as polkadot-js\n    if (!ALLOWED_SCRYPT_PARAMS.some((preset) => preset.N === N && preset.p === p && preset.r === r))\n      throw new Error(\"Invalid injected scrypt params found\")\n    key = deriveKey(password, salt, { N, p, r })\n    offset = SALT_LENGTH + SCRYPT_PARAMS_LENGTH\n  } else {\n    // legacy non-scrypt keystores use the raw password padded to 32 bytes\n    const padded = new Uint8Array(32)\n    padded.set(new TextEncoder().encode(password).subarray(0, 32))\n    key = padded\n  }\n\n  const nonce = bytes.subarray(offset, offset + NONCE_LENGTH)\n  const ciphertext = bytes.subarray(offset + NONCE_LENGTH)\n\n  return xsalsa20poly1305(key, nonce).decrypt(ciphertext)\n}\n\n/** Encrypts data as a polkadot-js keystore (`jsonEncrypt` equivalent, always scrypt + v3) */\nexport const encryptPjsKeystore = (\n  data: Uint8Array,\n  contentType: string[],\n  password: string\n): PjsKeystore => {\n  const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH))\n  const nonce = crypto.getRandomValues(new Uint8Array(NONCE_LENGTH))\n\n  const key = deriveKey(password, salt, { N: SCRYPT_N, p: SCRYPT_P, r: SCRYPT_R })\n  const ciphertext = xsalsa20poly1305(key, nonce).encrypt(data)\n\n  const encoded = new Uint8Array(\n    SALT_LENGTH + SCRYPT_PARAMS_LENGTH + NONCE_LENGTH + ciphertext.length\n  )\n  encoded.set(salt, 0)\n  encoded.set(writeU32LE(SCRYPT_N), SALT_LENGTH)\n  encoded.set(writeU32LE(SCRYPT_P), SALT_LENGTH + 4)\n  encoded.set(writeU32LE(SCRYPT_R), SALT_LENGTH + 8)\n  encoded.set(nonce, SALT_LENGTH + SCRYPT_PARAMS_LENGTH)\n  encoded.set(ciphertext, SALT_LENGTH + SCRYPT_PARAMS_LENGTH + NONCE_LENGTH)\n\n  return {\n    encoded: base64.encode(encoded),\n    encoding: {\n      content: contentType,\n      type: [\"scrypt\", \"xsalsa20-poly1305\"],\n      version: \"3\",\n    },\n  }\n}\n","import { detectAddressEncoding } from \"../address\"\nimport type { 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 { ed25519 } from \"@noble/curves/ed25519.js\"\nimport { secp256k1 } from \"@noble/curves/secp256k1.js\"\nimport { keccak_256 } from \"@noble/hashes/sha3.js\"\nimport { sign as sr25519Sign } from \"@scure/sr25519\"\n\nimport { blake2b256 } from \"../hashing\"\nimport type { KeypairCurve } from \"../types\"\n\n/** noble's recovered signature format is v||r||s, substrate expects r||s||v */\nconst toRsv = (vrs: Uint8Array): Uint8Array => {\n  const rsv = new Uint8Array(65)\n  rsv.set(vrs.subarray(1), 0)\n  rsv[64] = vrs[0]\n  return rsv\n}\n\n/**\n * Signs a substrate payload with the given curve.\n *\n * Output is byte-compatible with polkadot-js `KeyringPair.sign` (without type prefix):\n * - sr25519/ed25519: 64-byte signature over the raw message\n * - ecdsa: 65-byte recoverable signature (r||s||v) over blake2b-256(message)\n * - ethereum: 65-byte recoverable signature (r||s||v) over keccak-256(message)\n *\n * Note: callers are responsible for the substrate >256-byte rule (hash the payload\n * with blake2b-256 before signing) — this matches where polkadot-js applies it.\n */\nexport const signSubstrate = (\n  curve: KeypairCurve,\n  secretKey: Uint8Array,\n  message: Uint8Array\n): Uint8Array => {\n  switch (curve) {\n    case \"sr25519\":\n      return sr25519Sign(secretKey, message)\n    case \"ed25519\":\n      // substrate ed25519 secret keys may be stored as [seed(32) || publicKey(32)]; noble signs from the 32-byte seed\n      return ed25519.sign(message, secretKey.length === 64 ? secretKey.subarray(0, 32) : secretKey)\n    case \"ecdsa\":\n      // prehash: false — noble v2 would otherwise sha256 the digest again, breaking polkadot-js parity\n      return toRsv(\n        secp256k1.sign(blake2b256(message), secretKey, { format: \"recovered\", prehash: false })\n      )\n    case \"ethereum\":\n      return toRsv(\n        secp256k1.sign(keccak_256(message), secretKey, { format: \"recovered\", prehash: false })\n      )\n    default:\n      throw new Error(`Unsupported curve for substrate signing: ${curve}`)\n  }\n}\n\n/** MultiSignature enum variant index per signature scheme, used to type-prefix signatures */\nexport const SIGNATURE_TYPE_PREFIX: Partial<Record<KeypairCurve, number>> = {\n  ed25519: 0,\n  sr25519: 1,\n  ecdsa: 2,\n  ethereum: 2,\n}\n"],"mappings":"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"}