@hashgraphonline/standards-sdk 0.1.136-fix-hol-env.canary.a285980.31 → 0.1.137-feat-hcs-21.canary.5802d65.32

package/dist/es/standards-sdk.es113.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es113.js","sources":["../../src/utils/crypto-abstraction.ts"],"sourcesContent":["/**\n * Crypto Abstraction Layer\n *\n * Provides a unified interface for cryptographic operations that works\n * across Node.js, browser, and SSR environments.\n */\n\nimport { detectCryptoEnvironment } from './crypto-env';\nimport {\n  HashAdapter,\n  NodeHashAdapter,\n  WebHashAdapter,\n  FallbackHashAdapter,\n} from './hash-adapter';\n\n/**\n * HMAC Adapter interface\n */\nexport interface HmacAdapter {\n  update(data: Buffer): HmacAdapter;\n  digest(encoding?: string): string | Buffer | Promise<string | Buffer>;\n}\n\n/**\n * Node.js HMAC adapter\n */\nexport class NodeHmacAdapter implements HmacAdapter {\n  constructor(private nodeHmac: any) {}\n\n  update(data: Buffer): HmacAdapter {\n    this.nodeHmac.update(data);\n    return this;\n  }\n\n  digest(encoding?: string): string | Buffer {\n    return this.nodeHmac.digest(encoding);\n  }\n}\n\n/**\n * WebCrypto HMAC adapter\n */\nexport class WebHmacAdapter implements HmacAdapter {\n  private data: Buffer[] = [];\n\n  constructor(\n    private key: Buffer,\n    private algorithm: string = 'sha256',\n  ) {}\n\n  update(data: Buffer): HmacAdapter {\n    this.data.push(data);\n    return this;\n  }\n\n  async digest(encoding?: string): Promise<string | Buffer> {\n    const combined = Buffer.concat(this.data);\n    const keyBytes = new Uint8Array(this.key);\n    const keyBuffer = await crypto.subtle.importKey(\n      'raw',\n      keyBytes,\n      { name: 'HMAC', hash: this.mapAlgorithm(this.algorithm) },\n      false,\n      ['sign'],\n    );\n\n    const signature = await crypto.subtle.sign(\n      'HMAC',\n      keyBuffer,\n      new Uint8Array(combined),\n    );\n\n    if (encoding === 'hex') {\n      return Array.from(new Uint8Array(signature))\n        .map(b => b.toString(16).padStart(2, '0'))\n        .join('');\n    }\n\n    return Buffer.from(signature);\n  }\n\n  private mapAlgorithm(algorithm: string): string {\n    const algorithmMap: Record<string, string> = {\n      sha256: 'SHA-256',\n      sha1: 'SHA-1',\n      sha512: 'SHA-512',\n    };\n\n    return algorithmMap[algorithm.toLowerCase()] || 'SHA-256';\n  }\n}\n\n/**\n * Fallback HMAC adapter\n */\nexport class FallbackHmacAdapter implements HmacAdapter {\n  private data: Buffer[] = [];\n\n  constructor(\n    private key: Buffer,\n    private algorithm: string = 'sha256',\n  ) {}\n\n  update(data: Buffer): HmacAdapter {\n    this.data.push(data);\n    return this;\n  }\n\n  digest(encoding?: string): string {\n    const combined = Buffer.concat(this.data);\n    const hash = this.simpleHmac(combined, this.key);\n\n    if (encoding === 'hex') {\n      return hash.toString(16).padStart(8, '0');\n    }\n\n    return hash.toString();\n  }\n\n  private simpleHmac(data: Buffer, key: Buffer): number {\n    let hash = 0;\n    for (let i = 0; i < data.length; i++) {\n      const keyByte = key[i % key.length];\n      hash = ((hash << 5) - hash + data[i] + keyByte) & 0xffffffff;\n    }\n    return Math.abs(hash);\n  }\n}\n\n/**\n * Main crypto adapter interface\n */\nexport interface CryptoAdapter {\n  createHash(algorithm: string): HashAdapter;\n  createHmac(algorithm: string, key: Buffer): HmacAdapter;\n  pbkdf2(\n    password: string,\n    salt: Buffer,\n    iterations: number,\n    keylen: number,\n    digest: string,\n  ): Promise<Buffer>;\n  timingSafeEqual(a: Buffer, b: Buffer): boolean;\n}\n\ndeclare const require: any;\n\n/**\n * Node.js crypto adapter\n */\nexport class NodeCryptoAdapter implements CryptoAdapter {\n  private crypto: any;\n\n  constructor() {\n    try {\n      const moduleName = 'cry' + 'pto';\n      this.crypto = require(moduleName);\n    } catch (error) {\n      throw new Error('Node.js crypto module not available');\n    }\n  }\n\n  createHash(algorithm: string): HashAdapter {\n    return new NodeHashAdapter(this.crypto.createHash(algorithm));\n  }\n\n  createHmac(algorithm: string, key: Buffer): HmacAdapter {\n    return new NodeHmacAdapter(this.crypto.createHmac(algorithm, key));\n  }\n\n  async pbkdf2(\n    password: string,\n    salt: Buffer,\n    iterations: number,\n    keylen: number,\n    digest: string,\n  ): Promise<Buffer> {\n    return new Promise((resolve, reject) => {\n      this.crypto.pbkdf2(\n        password,\n        salt,\n        iterations,\n        keylen,\n        digest,\n        (err: any, derivedKey: Buffer) => {\n          if (err) reject(err);\n          else resolve(derivedKey);\n        },\n      );\n    });\n  }\n\n  timingSafeEqual(a: Buffer, b: Buffer): boolean {\n    return this.crypto.timingSafeEqual(a, b);\n  }\n}\n\n/**\n * WebCrypto adapter\n */\nexport class WebCryptoAdapter implements CryptoAdapter {\n  createHash(algorithm: string): HashAdapter {\n    return new WebHashAdapter(algorithm);\n  }\n\n  createHmac(algorithm: string, key: Buffer): HmacAdapter {\n    return new WebHmacAdapter(key, algorithm);\n  }\n\n  async pbkdf2(\n    password: string,\n    salt: Buffer,\n    iterations: number,\n    keylen: number,\n    digest: string,\n  ): Promise<Buffer> {\n    const encoder = new TextEncoder();\n    const keyMaterial = await crypto.subtle.importKey(\n      'raw',\n      encoder.encode(password),\n      { name: 'PBKDF2' },\n      false,\n      ['deriveBits'],\n    );\n\n    const derivedBits = await crypto.subtle.deriveBits(\n      {\n        name: 'PBKDF2',\n        salt: new Uint8Array(salt),\n        iterations: iterations,\n        hash: this.mapDigest(digest),\n      },\n      keyMaterial,\n      keylen * 8,\n    );\n\n    return Buffer.from(derivedBits);\n  }\n\n  timingSafeEqual(a: Buffer, b: Buffer): boolean {\n    if (a.length !== b.length) return false;\n\n    let result = 0;\n    for (let i = 0; i < a.length; i++) {\n      result |= a[i] ^ b[i];\n    }\n    return result === 0;\n  }\n\n  private mapDigest(digest: string): string {\n    const digestMap: Record<string, string> = {\n      sha256: 'SHA-256',\n      sha1: 'SHA-1',\n      sha512: 'SHA-512',\n    };\n\n    return digestMap[digest.toLowerCase()] || 'SHA-256';\n  }\n}\n\n/**\n * Fallback crypto adapter for SSR\n */\nexport class FallbackCryptoAdapter implements CryptoAdapter {\n  createHash(algorithm: string): HashAdapter {\n    return new FallbackHashAdapter(algorithm);\n  }\n\n  createHmac(algorithm: string, key: Buffer): HmacAdapter {\n    return new FallbackHmacAdapter(key, algorithm);\n  }\n\n  async pbkdf2(\n    password: string,\n    salt: Buffer,\n    iterations: number,\n    keylen: number,\n    digest: string,\n  ): Promise<Buffer> {\n    const encoder = new TextEncoder();\n    const passwordBuffer = Buffer.from(encoder.encode(password));\n    let result = Buffer.alloc(keylen);\n\n    for (let i = 0; i < iterations; i++) {\n      const combined = Buffer.concat([passwordBuffer, salt, Buffer.from([i])]);\n      let hash = 0;\n      for (let j = 0; j < combined.length; j++) {\n        hash = ((hash << 5) - hash + combined[j]) & 0xffffffff;\n      }\n      result[i % keylen] ^= hash & 0xff;\n    }\n\n    return result;\n  }\n\n  timingSafeEqual(a: Buffer, b: Buffer): boolean {\n    if (a.length !== b.length) return false;\n\n    let result = 0;\n    for (let i = 0; i < a.length; i++) {\n      result |= a[i] ^ b[i];\n    }\n    return result === 0;\n  }\n}\n\n/**\n * Get appropriate crypto adapter for current environment\n */\nexport function getCryptoAdapter(): CryptoAdapter {\n  const env = detectCryptoEnvironment();\n\n  switch (env.preferredAPI) {\n    case 'node':\n      try {\n        return new NodeCryptoAdapter();\n      } catch {\n        return new FallbackCryptoAdapter();\n      }\n    case 'web':\n      return new WebCryptoAdapter();\n    case 'none':\n    default:\n      return new FallbackCryptoAdapter();\n  }\n}\n\n/**\n * Convenience function for simple hash operations\n */\nexport async function hash(\n  content: Buffer | string,\n  algorithm: string = 'sha256',\n): Promise<string> {\n  const adapter = getCryptoAdapter();\n  const hasher = adapter.createHash(algorithm);\n  const buffer = typeof content === 'string' ? Buffer.from(content) : content;\n  const result = hasher.update(buffer).digest('hex');\n\n  if (result instanceof Promise) {\n    return (await result) as string;\n  }\n\n  return result as string;\n}\n"],"names":["hash"],"mappings":"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"}
+{"version":3,"file":"standards-sdk.es113.js","sources":["../../src/utils/key-type-detector.ts"],"sourcesContent":["import { PrivateKey } from '@hashgraph/sdk';\n\n/**\n * Enumeration of supported key types\n */\nexport enum KeyType {\n  ED25519 = 'ed25519',\n  ECDSA = 'ecdsa',\n  UNKNOWN = 'unknown',\n}\n\n/**\n * Result of key type detection\n */\nexport interface KeyInfo {\n  /** Detected key type (ED25519, ECDSA, or UNKNOWN) */\n  type: KeyType;\n  /** Format of the provided key */\n  format: 'hex' | 'der' | 'pem' | 'raw';\n  /** Whether the key is a private key */\n  isPrivateKey: boolean;\n  /** Raw bytes of the key (if available) */\n  rawBytes?: Uint8Array;\n  /** Confidence level of the detection */\n  confidence: 'certain' | 'uncertain';\n  /** Warning message for uncertain detections */\n  warning?: string;\n}\n\n/**\n * Legacy interface for backward compatibility\n */\nexport interface KeyDetectionResult {\n  /** Detected key type */\n  detectedType: 'ed25519' | 'ecdsa';\n  /** Parsed private key */\n  privateKey: PrivateKey;\n  /** Optional warning for ambiguous keys */\n  warning?: string;\n}\n\n/**\n * Utility class for detecting cryptographic key types used in Hedera\n *\n * This class provides methods to determine whether a key is ED25519 or ECDSA\n * based on various input formats (hex, DER, PEM) and detection strategies.\n *\n * For ambiguous 32-byte raw keys, it uses heuristics and signature testing\n * to make a best-effort determination. When confidence is 'uncertain',\n * consider using the Hedera mirror node to confirm the key type if you have\n * the associated account ID.\n *\n * @example\n * // Detect key type from a hex string\n * const keyInfo = KeyTypeDetector.detect('0x' + privateKey.toStringRaw());\n * if (keyInfo.confidence === 'uncertain') {\n *   console.warn(keyInfo.warning);\n *   // Consider checking mirror node if account ID is available\n * }\n */\nexport class KeyTypeDetector {\n  private static readonly ED25519_PUBLIC_KEY_LENGTH = 32;\n  private static readonly ED25519_EXPANDED_PRIVATE_KEY_LENGTH = 64;\n\n  private static readonly ED25519_PUBLIC_KEY_PREFIX = Buffer.from([\n    0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00,\n  ]);\n  private static readonly ED25519_PRIVATE_KEY_PREFIX = Buffer.from([\n    0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70,\n    0x04, 0x22, 0x04, 0x20,\n  ]);\n\n  private static readonly ECDSA_SECP256K1_PUBLIC_KEY_PREFIX = Buffer.from([\n    0x30, 0x56, 0x30, 0x10, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,\n    0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a, 0x03, 0x42, 0x00,\n  ]);\n  private static readonly ECDSA_SECP256K1_PRIVATE_KEY_PREFIX = Buffer.from([\n    0x30, 0x74, 0x02, 0x01, 0x01, 0x04, 0x20,\n  ]);\n  private static readonly ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT =\n    Buffer.from([\n      0x30, 0x30, 0x02, 0x01, 0x00, 0x30, 0x07, 0x06, 0x05, 0x2b, 0x81, 0x04,\n      0x00, 0x0a, 0x04, 0x22, 0x04, 0x20,\n    ]);\n\n  private static readonly ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG = Buffer.from(\n    [0x30, 0x77, 0x02, 0x01, 0x01, 0x04, 0x20],\n  );\n\n  /**\n   * Detects private key type from various input formats without throwing errors\n   *\n   * This detector is designed for private keys only. It uses various heuristics to determine\n   * the key type for ambiguous 32-byte keys, including byte patterns and statistical analysis.\n   *\n   * For ambiguous cases (where confidence is 'uncertain'), if you have the associated account ID,\n   * you can use the Hedera mirror node to confirm the key type.\n   *\n   * @param keyInput - The key to detect, can be a string (hex, base64, PEM), Buffer, or Uint8Array\n   * @returns KeyInfo object containing the detected key type and metadata\n   *\n   * @example\n   * // Detect from hex string\n   * const info1 = KeyTypeDetector.detect('0x7f96cea0c0d9d5bfb3ab8a42cf0cea44d57f62f2e068f8e5a3251914a9252b04');\n   *\n   * // Detect from DER-encoded string\n   * const info2 = KeyTypeDetector.detect(privateKey.toStringDer());\n   *\n   * // Detect from PEM format\n   * const info3 = KeyTypeDetector.detect(`-----BEGIN PRIVATE KEY-----\n   * MC4CAQAwBQYDK2VwBCIEIGRchBsQGQduAAGBQ7GAkKCKkmQ3EGCARwHsHiRqTNR9\n   * -----END PRIVATE KEY-----`);\n   */\n  static detect(keyInput: string | Uint8Array | Buffer): KeyInfo {\n    try {\n      let keyBytes: Uint8Array;\n      let originalFormat: 'hex' | 'der' | 'pem' | 'raw' = 'raw';\n\n      if (typeof keyInput === 'string') {\n        let trimmed = keyInput.trim();\n\n        if (trimmed.includes('-----BEGIN')) {\n          return this.detectFromPem(trimmed);\n        }\n\n        if (trimmed.toLowerCase().startsWith('0x')) {\n          trimmed = trimmed.substring(2);\n        }\n\n        if (this.isValidHex(trimmed)) {\n          keyBytes = this.hexToBytes(trimmed);\n          originalFormat = 'hex';\n        } else if (this.isBase64(trimmed)) {\n          keyBytes = Buffer.from(trimmed, 'base64');\n          originalFormat = 'der';\n        } else {\n          return {\n            type: KeyType.UNKNOWN,\n            format: 'raw',\n            isPrivateKey: false,\n            confidence: 'certain',\n          };\n        }\n      } else if (keyInput instanceof Buffer) {\n        keyBytes = new Uint8Array(keyInput);\n      } else {\n        keyBytes = keyInput as Uint8Array;\n      }\n\n      return this.detectFromBytes(keyBytes, originalFormat);\n    } catch (error) {\n      return {\n        type: KeyType.UNKNOWN,\n        format: 'raw',\n        isPrivateKey: false,\n        confidence: 'certain',\n      };\n    }\n  }\n\n  /**\n   * Detect key type from raw bytes\n   *\n   * @param bytes - The raw bytes of the key\n   * @param format - The original format of the key\n   * @returns KeyInfo object with detection results\n   * @private\n   */\n  private static detectFromBytes(\n    bytes: Uint8Array,\n    format: 'hex' | 'der' | 'pem' | 'raw',\n  ): KeyInfo {\n    if (this.hasPrefix(bytes, this.ED25519_PUBLIC_KEY_PREFIX)) {\n      const keyStart = this.ED25519_PUBLIC_KEY_PREFIX.length;\n      return {\n        type: KeyType.ED25519,\n        format: 'der',\n        isPrivateKey: false,\n        rawBytes: bytes.slice(keyStart),\n        confidence: 'certain',\n      };\n    }\n\n    if (this.hasPrefix(bytes, this.ED25519_PRIVATE_KEY_PREFIX)) {\n      const keyStart = this.ED25519_PRIVATE_KEY_PREFIX.length;\n      if (bytes.length >= keyStart + 32) {\n        return {\n          type: KeyType.ED25519,\n          format: 'der',\n          isPrivateKey: true,\n          rawBytes: bytes.slice(keyStart, keyStart + 32),\n          confidence: 'certain',\n        };\n      }\n    }\n\n    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX)) {\n      const keyStart = this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX.length;\n      return {\n        type: KeyType.ECDSA,\n        format: 'der',\n        isPrivateKey: false,\n        rawBytes: bytes.slice(keyStart),\n        confidence: 'certain',\n      };\n    }\n\n    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT)) {\n      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT.length;\n      return {\n        type: KeyType.ECDSA,\n        format: 'der',\n        isPrivateKey: true,\n        rawBytes: bytes.slice(keyStart),\n        confidence: 'certain',\n      };\n    }\n\n    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX)) {\n      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX.length;\n      return {\n        type: KeyType.ECDSA,\n        format: 'der',\n        isPrivateKey: true,\n        rawBytes: bytes.slice(keyStart, keyStart + 32),\n        confidence: 'certain',\n      };\n    }\n\n    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG)) {\n      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG.length;\n      return {\n        type: KeyType.ECDSA,\n        format: 'der',\n        isPrivateKey: true,\n        rawBytes: bytes.slice(keyStart, keyStart + 32),\n        confidence: 'certain',\n      };\n    }\n\n    if (bytes.length > 36 && this.containsECDSAPrivateKeyPattern(bytes)) {\n      return {\n        type: KeyType.ECDSA,\n        format: 'der',\n        isPrivateKey: true,\n        rawBytes: this.extractECDSAPrivateKey(bytes),\n        confidence: 'certain',\n      };\n    }\n\n    switch (bytes.length) {\n      case this.ED25519_PUBLIC_KEY_LENGTH:\n        if (format === 'hex') {\n          const hexStr = Array.from(bytes)\n            .map(b => b.toString(16).padStart(2, '0'))\n            .join('');\n\n          const privateResult = this.tryCreateKey(hexStr);\n          if (privateResult.type !== KeyType.UNKNOWN) {\n            return privateResult;\n          }\n        }\n\n        return {\n          type: KeyType.UNKNOWN,\n          format: format,\n          isPrivateKey: false,\n          rawBytes: bytes,\n          confidence: 'certain',\n        };\n\n      case this.ED25519_EXPANDED_PRIVATE_KEY_LENGTH:\n        return {\n          type: KeyType.ED25519,\n          format: format,\n          isPrivateKey: true,\n          rawBytes: bytes,\n          confidence: 'certain',\n        };\n    }\n\n    return {\n      type: KeyType.UNKNOWN,\n      format: format,\n      isPrivateKey: false,\n      rawBytes: bytes,\n      confidence: 'certain',\n    };\n  }\n\n  /**\n   * Detect key type from PEM format\n   *\n   * @param pem - The PEM-encoded key string\n   * @returns KeyInfo object with detection results\n   * @private\n   */\n  private static detectFromPem(pem: string): KeyInfo {\n    const trimmedPem = pem.trim();\n    const isPrivateKey = trimmedPem.includes('PRIVATE KEY');\n\n    const pemTypes = {\n      EC_PRIVATE: /-----BEGIN EC PRIVATE KEY-----/,\n      EC_PUBLIC: /-----BEGIN EC PUBLIC KEY-----/,\n      PRIVATE: /-----BEGIN PRIVATE KEY-----/,\n      PUBLIC: /-----BEGIN PUBLIC KEY-----/,\n    };\n\n    let isECKey = false;\n    for (const [type, regex] of Object.entries(pemTypes)) {\n      if (regex.test(trimmedPem) && type.includes('EC')) {\n        isECKey = true;\n        break;\n      }\n    }\n\n    const base64Match = trimmedPem.match(\n      /-----BEGIN[\\s\\S]+?-----[\\r\\n]+([\\s\\S]+?)[\\r\\n]+-----END/,\n    );\n    if (!base64Match) {\n      return {\n        type: KeyType.UNKNOWN,\n        format: 'pem',\n        isPrivateKey,\n        confidence: 'certain',\n      };\n    }\n\n    const base64Content = base64Match[1].replace(/\\s/g, '');\n    try {\n      const derBytes = Buffer.from(base64Content, 'base64');\n      const result = this.detectFromBytes(new Uint8Array(derBytes), 'der');\n\n      if (result.type === KeyType.UNKNOWN && isECKey) {\n        return {\n          type: KeyType.ECDSA,\n          format: 'pem',\n          isPrivateKey,\n          rawBytes: derBytes,\n          confidence: 'certain',\n        };\n      }\n\n      return {\n        ...result,\n        format: 'pem',\n      };\n    } catch {\n      return {\n        type: KeyType.UNKNOWN,\n        format: 'pem',\n        isPrivateKey,\n        confidence: 'certain',\n      };\n    }\n  }\n\n  /**\n   * Try to create a key using Hedera SDK to validate the type\n   *\n   * @param keyInput - The key input string or bytes\n   * @returns KeyInfo object with detection results\n   * @private\n   */\n  private static tryCreateKey(keyInput: string | Uint8Array): KeyInfo {\n    try {\n      if (typeof keyInput === 'string') {\n        let keyStr = keyInput.trim();\n        if (keyStr.toLowerCase().startsWith('0x')) {\n          keyStr = keyStr.substring(2);\n        }\n\n        if (this.isValidHex(keyStr) && keyStr.length === 64) {\n          const keyBytes = this.hexToBytes(keyStr);\n\n          const signatureResult = this.detectBySignature(keyStr);\n          if (signatureResult.type !== KeyType.UNKNOWN) {\n            return {\n              type: signatureResult.type,\n              format: 'hex',\n              isPrivateKey: true,\n              rawBytes: keyBytes,\n              confidence: signatureResult.confidence,\n              warning: signatureResult.warning,\n            };\n          }\n\n          return {\n            type: KeyType.UNKNOWN,\n            format: 'hex',\n            isPrivateKey: false,\n            rawBytes: keyBytes,\n            confidence: 'certain',\n          };\n        }\n      }\n    } catch {}\n\n    return {\n      type: KeyType.UNKNOWN,\n      format: 'hex',\n      isPrivateKey: false,\n      rawBytes: new Uint8Array(),\n      confidence: 'certain',\n    };\n  }\n\n  /**\n   * Detect key type by attempting to sign a message with both algorithms\n   *\n   * For ambiguous cases where both algorithms can use the key, this method\n   * uses heuristics to make a best-effort determination. For production use\n   * with ambiguous keys, consider using the Hedera mirror node to confirm\n   * the key type if you have the associated account ID.\n   *\n   * @param hexKey - The hex string representation of the key\n   * @returns Object containing type, confidence level, and optional warning\n   * @private\n   */\n  private static detectBySignature(hexKey: string): {\n    type: KeyType;\n    confidence: 'certain' | 'uncertain';\n    warning?: string;\n  } {\n    const keyBigInt = BigInt('0x' + hexKey);\n    const secp256k1Order = BigInt(\n      '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141',\n    );\n\n    if (keyBigInt === 0n) {\n      return {\n        type: KeyType.ED25519,\n        confidence: 'certain',\n      };\n    }\n\n    if (keyBigInt >= secp256k1Order) {\n      return {\n        type: KeyType.ED25519,\n        confidence: 'certain',\n      };\n    }\n\n    let ed25519CanSign = false;\n    let ecdsaCanSign = false;\n\n    try {\n      const ed25519Key = PrivateKey.fromStringED25519(hexKey);\n      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);\n      const signature = ed25519Key.sign(testMessage);\n      if (ed25519Key.publicKey.verify(testMessage, signature)) {\n        ed25519CanSign = true;\n      }\n    } catch {}\n\n    try {\n      const ecdsaKey = PrivateKey.fromStringECDSA(hexKey);\n      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);\n      const signature = ecdsaKey.sign(testMessage);\n      if (ecdsaKey.publicKey.verify(testMessage, signature)) {\n        ecdsaCanSign = true;\n      }\n    } catch {}\n\n    if (ed25519CanSign && ecdsaCanSign) {\n      const keyBytes = this.hexToBytes(hexKey);\n\n      if (keyBytes[0] === 0xa8 && keyBytes[1] === 0x01) {\n        return {\n          type: KeyType.ED25519,\n          confidence: 'uncertain',\n          warning:\n            'Detection based on byte pattern heuristic. Both ED25519 and ECDSA accept this key.',\n        };\n      }\n\n      let highBytes = 0;\n      for (const byte of keyBytes) {\n        if (byte >= 0x80) highBytes++;\n      }\n\n      const highByteRatio = highBytes / keyBytes.length;\n      if (highByteRatio >= 0.4 && highByteRatio <= 0.6) {\n        return {\n          type: KeyType.ECDSA,\n          confidence: 'uncertain',\n          warning:\n            'Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key.',\n        };\n      }\n\n      return {\n        type: KeyType.ECDSA,\n        confidence: 'uncertain',\n        warning:\n          'Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key. Defaulting to ECDSA.',\n      };\n    }\n\n    if (ed25519CanSign && !ecdsaCanSign) {\n      return {\n        type: KeyType.ED25519,\n        confidence: 'certain',\n      };\n    }\n\n    if (ecdsaCanSign && !ed25519CanSign) {\n      return {\n        type: KeyType.ECDSA,\n        confidence: 'certain',\n      };\n    }\n\n    return {\n      type: KeyType.UNKNOWN,\n      confidence: 'certain',\n    };\n  }\n\n  /**\n   * Check if a string is valid hexadecimal with even length\n   *\n   * @param str - The string to check\n   * @returns True if the string is valid hex with even length\n   * @private\n   */\n  private static isValidHex(str: string): boolean {\n    return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;\n  }\n\n  /**\n   * Check if a string is valid base64\n   *\n   * @param str - The string to check\n   * @returns True if the string is valid base64\n   * @private\n   */\n  private static isBase64(str: string): boolean {\n    try {\n      return Buffer.from(str, 'base64').toString('base64') === str;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Convert a hex string to bytes\n   *\n   * @param hex - The hex string to convert\n   * @returns Uint8Array of bytes\n   * @private\n   */\n  private static hexToBytes(hex: string): Uint8Array {\n    const bytes = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < hex.length; i += 2) {\n      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);\n    }\n    return bytes;\n  }\n\n  /**\n   * Check if bytes start with a specific prefix\n   *\n   * @param bytes - The bytes to check\n   * @param prefix - The prefix to look for\n   * @returns True if bytes start with the prefix\n   * @private\n   */\n  private static hasPrefix(bytes: Uint8Array, prefix: Buffer): boolean {\n    if (bytes.length < prefix.length) return false;\n    for (let i = 0; i < prefix.length; i++) {\n      if (bytes[i] !== prefix[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Check if bytes contain an ECDSA private key pattern\n   *\n   * @param bytes - The bytes to check\n   * @returns True if ECDSA private key pattern is found\n   * @private\n   */\n  private static containsECDSAPrivateKeyPattern(bytes: Uint8Array): boolean {\n    for (let i = 0; i < bytes.length - 7; i++) {\n      if (\n        bytes[i] === 0x30 &&\n        bytes[i + 1] === 0x74 &&\n        bytes[i + 2] === 0x02 &&\n        bytes[i + 3] === 0x01 &&\n        bytes[i + 4] === 0x01 &&\n        bytes[i + 5] === 0x04 &&\n        bytes[i + 6] === 0x20\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Extract ECDSA private key from DER structure\n   *\n   * @param bytes - The DER encoded bytes\n   * @returns The extracted private key bytes\n   * @private\n   */\n  private static extractECDSAPrivateKey(bytes: Uint8Array): Uint8Array {\n    for (let i = 0; i < bytes.length - 32; i++) {\n      if (bytes[i] === 0x04 && bytes[i + 1] === 0x20) {\n        return bytes.slice(i + 2, i + 34);\n      }\n    }\n    return bytes;\n  }\n}\n\n/**\n * Detects the key type from a private key string and returns the parsed PrivateKey\n *\n * This function leverages the KeyTypeDetector class to determine whether a key is\n * ED25519 or ECDSA. It handles parsing the key and provides appropriate warnings\n * for uncertain detections.\n *\n * Note: For ambiguous keys, if you have the associated account ID, consider using\n * the Hedera mirror node to confirm the key type for production use.\n *\n * @param privateKeyString The private key string to detect type from\n * @returns The detected key type, parsed PrivateKey, and optional warning\n * @throws Error if the private key cannot be parsed\n */\nexport function detectKeyTypeFromString(\n  privateKeyString: string,\n): KeyDetectionResult {\n  const keyInfo = KeyTypeDetector.detect(privateKeyString);\n\n  if (keyInfo.type !== KeyType.UNKNOWN) {\n    try {\n      const privateKey =\n        keyInfo.type === KeyType.ECDSA\n          ? PrivateKey.fromStringECDSA(privateKeyString)\n          : PrivateKey.fromStringED25519(privateKeyString);\n\n      const result: KeyDetectionResult = {\n        detectedType: keyInfo.type as 'ed25519' | 'ecdsa',\n        privateKey,\n      };\n\n      if (keyInfo.confidence === 'uncertain') {\n        result.warning =\n          `Key type detection is uncertain. If you have the associated account ID, ` +\n          `consider using the Hedera mirror node to confirm the key type.`;\n      }\n\n      return result;\n    } catch (error) {}\n  }\n\n  try {\n    const privateKey = PrivateKey.fromStringECDSA(privateKeyString);\n    return {\n      detectedType: 'ecdsa',\n      privateKey,\n      warning: `Using ECDSA as default. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`,\n    };\n  } catch (ecdsaError) {\n    try {\n      const privateKey = PrivateKey.fromStringED25519(privateKeyString);\n      return {\n        detectedType: 'ed25519',\n        privateKey,\n        warning: `Using ED25519 as fallback. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`,\n      };\n    } catch (ed25519Error) {\n      throw new Error(\n        `Failed to parse private key as either ECDSA or ED25519: ${ecdsaError}`,\n      );\n    }\n  }\n}\n"],"names":["KeyType"],"mappings":"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"}