@hashgraphonline/standards-sdk 0.1.168 → 0.1.170

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es126.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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"}
+{"version":3,"file":"standards-sdk.es126.js","sources":["../../src/utils/progress-reporter.ts"],"sourcesContent":["import { Logger, ILogger } from './logger';\n\nexport type ProgressStage =\n  | 'preparing'\n  | 'submitting'\n  | 'confirming'\n  | 'verifying'\n  | 'completed'\n  | 'failed';\n\nexport interface ProgressData {\n  stage: ProgressStage;\n  message: string;\n  progressPercent: number;\n  details?: Record<string, any>;\n}\n\nexport type ProgressCallback = (data: ProgressData) => void;\n\nexport interface ProgressReporterOptions {\n  module?: string;\n  callback?: ProgressCallback;\n  logger?: ILogger;\n  logProgress?: boolean;\n  minPercent?: number;\n  maxPercent?: number;\n}\n\n/**\n * ProgressReporter is a singleton class that reports progress of a task.\n * Can be used in a generalized fashion.\n */\nexport class ProgressReporter {\n  private static instance: ProgressReporter;\n  private module: string;\n  private callback?: ProgressCallback;\n  private logger: ILogger;\n  private logProgress: boolean;\n  private minPercent: number;\n  private maxPercent: number;\n  private lastReportedPercent: number;\n  private lastReportedTime: number;\n  private throttleMs: number;\n\n  constructor(options: ProgressReporterOptions = {}) {\n    this.module = options.module || 'Progress';\n    this.callback = options.callback;\n    this.logger =\n      options.logger ||\n      new Logger({\n        level: 'info',\n        module: 'ProgressReporter',\n      });\n    this.logProgress = options.logProgress ?? true;\n    this.minPercent = options.minPercent ?? 0;\n    this.maxPercent = options.maxPercent ?? 100;\n    this.lastReportedPercent = -1;\n    this.lastReportedTime = 0;\n    this.throttleMs = 100;\n  }\n\n  static getInstance(options: ProgressReporterOptions = {}): ProgressReporter {\n    if (!ProgressReporter.instance) {\n      ProgressReporter.instance = new ProgressReporter(options);\n    } else {\n      if (options.callback) {\n        ProgressReporter.instance.setCallback(options.callback);\n      }\n      if (options.module) {\n        ProgressReporter.instance.setModule(options.module);\n      }\n      if (options.logger) {\n        ProgressReporter.instance.setLogger(options.logger);\n      }\n      if (options.minPercent !== undefined) {\n        ProgressReporter.instance.setMinPercent(options.minPercent);\n      }\n      if (options.maxPercent !== undefined) {\n        ProgressReporter.instance.setMaxPercent(options.maxPercent);\n      }\n    }\n    return ProgressReporter.instance;\n  }\n\n  setCallback(callback: ProgressCallback): void {\n    this.callback = callback;\n  }\n\n  setModule(module: string): void {\n    this.module = module;\n  }\n\n  setLogger(logger: ILogger): void {\n    this.logger = logger;\n  }\n\n  setMinPercent(minPercent: number): void {\n    this.minPercent = minPercent;\n  }\n\n  setMaxPercent(maxPercent: number): void {\n    this.maxPercent = maxPercent;\n  }\n\n  createSubProgress(options: {\n    minPercent: number;\n    maxPercent: number;\n    logPrefix?: string;\n  }): ProgressReporter {\n    const subReporter = new ProgressReporter({\n      module: this.module,\n      logger: this.logger,\n      logProgress: this.logProgress,\n      minPercent: options.minPercent,\n      maxPercent: options.maxPercent,\n    });\n\n    const logPrefix = options.logPrefix || '';\n\n    subReporter.setCallback(data => {\n      const scaledPercent = this.scalePercent(\n        data.progressPercent,\n        options.minPercent,\n        options.maxPercent,\n      );\n\n      let formattedMessage = data.message;\n      if (logPrefix && !formattedMessage.startsWith(logPrefix)) {\n        formattedMessage = `${logPrefix}: ${formattedMessage}`;\n      }\n\n      this.report({\n        stage: data.stage,\n        message: formattedMessage,\n        progressPercent: scaledPercent,\n        details: data.details,\n      });\n    });\n\n    return subReporter;\n  }\n\n  report(data: ProgressData): void {\n    const rawPercent = data.progressPercent;\n    const percent = Math.max(0, Math.min(100, rawPercent));\n\n    const scaledPercent = this.scalePercent(percent, 0, 100);\n\n    const now = Date.now();\n    if (\n      scaledPercent === this.lastReportedPercent &&\n      now - this.lastReportedTime < this.throttleMs &&\n      data.stage !== 'completed' &&\n      data.stage !== 'failed'\n    ) {\n      return;\n    }\n\n    this.lastReportedPercent = scaledPercent;\n    this.lastReportedTime = now;\n\n    const progressData = {\n      ...data,\n      progressPercent: scaledPercent,\n    };\n\n    if (this.logProgress) {\n      this.logger.debug(\n        `[${this.module}] [${data.stage.toUpperCase()}] ${\n          data.message\n        } (${scaledPercent.toFixed(1)}%)`,\n        data.details,\n      );\n    }\n\n    if (this.callback) {\n      try {\n        this.callback(progressData);\n      } catch (err) {\n        this.logger.warn(`Error in progress callback: ${err}`);\n      }\n    }\n  }\n\n  private scalePercent(\n    percent: number,\n    sourceMin: number,\n    sourceMax: number,\n  ): number {\n    const range = this.maxPercent - this.minPercent;\n    const sourceRange = sourceMax - sourceMin;\n    const scaleFactor = range / sourceRange;\n\n    return this.minPercent + (percent - sourceMin) * scaleFactor;\n  }\n\n  preparing(\n    message: string,\n    percent: number,\n    details?: Record<string, any>,\n  ): void {\n    this.report({\n      stage: 'preparing',\n      message,\n      progressPercent: percent,\n      details,\n    });\n  }\n\n  submitting(\n    message: string,\n    percent: number,\n    details?: Record<string, any>,\n  ): void {\n    this.report({\n      stage: 'submitting',\n      message,\n      progressPercent: percent,\n      details,\n    });\n  }\n\n  confirming(\n    message: string,\n    percent: number,\n    details?: Record<string, any>,\n  ): void {\n    this.report({\n      stage: 'confirming',\n      message,\n      progressPercent: percent,\n      details,\n    });\n  }\n\n  verifying(\n    message: string,\n    percent: number,\n    details?: Record<string, any>,\n  ): void {\n    this.report({\n      stage: 'verifying',\n      message,\n      progressPercent: percent,\n      details,\n    });\n  }\n\n  completed(message: string, details?: Record<string, any>): void {\n    this.report({ stage: 'completed', message, progressPercent: 100, details });\n  }\n\n  failed(message: string, details?: Record<string, any>): void {\n    this.report({\n      stage: 'failed',\n      message,\n      progressPercent: this.lastReportedPercent,\n      details,\n    });\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/es/standards-sdk.es127.js

@@ -1,16 +1,206 @@
-function getTopicId(inscription) {
-  if (!inscription || typeof inscription !== "object") return void 0;
-  const obj = inscription;
-  const direct = obj.topicId || obj.topic_id;
-  if (typeof direct === "string" && direct.trim()) return direct;
-  const rec = obj;
-  const t1 = rec["topicId"];
-  if (typeof t1 === "string" && t1.trim()) return t1;
-  const t2 = rec["topic_id"];
-  if (typeof t2 === "string" && t2.trim()) return t2;
-  return void 0;
+import axios from "axios";
+import { Logger } from "./standards-sdk.es123.js";
+import { HederaMirrorNode } from "./standards-sdk.es144.js";
+import "path";
+import "buffer";
+import "crypto";
+import "@noble/curves/secp256k1.js";
+import "./standards-sdk.es145.js";
+import "./standards-sdk.es147.js";
+import "zod";
+class HRLResolver {
+  constructor(logLevel = "info") {
+    this.defaultEndpoint = "https://kiloscribe.com/api/inscription-cdn";
+    this.logger = Logger.getInstance({
+      level: logLevel,
+      module: "HRLResolver"
+    });
+  }
+  /**
+   * Determines if a MIME type represents binary content
+   */
+  isBinaryContentType(mimeType) {
+    const binaryTypes = [
+      "image/",
+      "audio/",
+      "video/",
+      "application/octet-stream",
+      "application/pdf",
+      "application/zip",
+      "application/gzip",
+      "application/x-binary",
+      "application/vnd.ms-",
+      "application/x-msdownload",
+      "application/x-shockwave-flash",
+      "font/",
+      "application/wasm"
+    ];
+    return binaryTypes.some((prefix) => mimeType.startsWith(prefix));
+  }
+  /**
+   * Parses an HRL string into its components
+   */
+  parseHRL(hrl) {
+    if (!hrl) {
+      return null;
+    }
+    const hrlPattern = /^hcs:\/\/(\d+)\/([0-9]+\.[0-9]+\.[0-9]+)$/;
+    const match = hrl.match(hrlPattern);
+    if (!match) {
+      return null;
+    }
+    return {
+      standard: match[1],
+      topicId: match[2]
+    };
+  }
+  /**
+   * Validates if a string is a valid HRL
+   */
+  isValidHRL(hrl) {
+    if (!hrl || typeof hrl !== "string") {
+      return false;
+    }
+    const parsed = this.parseHRL(hrl);
+    if (!parsed) {
+      return false;
+    }
+    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+    if (!topicIdPattern.test(parsed.topicId)) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Validates if a string is a valid topic ID
+   */
+  isValidTopicId(topicId) {
+    const topicIdPattern = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+    return topicIdPattern.test(topicId);
+  }
+  /**
+   * Resolves content from either an HRL or a topic ID
+   * If a topic ID is provided, it queries the topic memo to determine the HCS standard
+   */
+  async resolve(hrlOrTopicId, options) {
+    if (this.isValidHRL(hrlOrTopicId)) {
+      return this.resolveHRL(hrlOrTopicId, options);
+    }
+    if (!this.isValidTopicId(hrlOrTopicId)) {
+      throw new Error(`Invalid HRL or topic ID format: ${hrlOrTopicId}`);
+    }
+    try {
+      const mirrorNode = new HederaMirrorNode(options.network, this.logger);
+      const topicInfo = await mirrorNode.getTopicInfo(hrlOrTopicId);
+      const memo = topicInfo?.memo || "";
+      let standard = "1";
+      if (memo) {
+        const hcsMatch = memo.match(/^hcs-(\d+)/);
+        if (hcsMatch && hcsMatch[1]) {
+          standard = hcsMatch[1];
+        }
+      }
+      const hrl = `hcs://${standard}/${hrlOrTopicId}`;
+      return this.resolveHRL(hrl, options);
+    } catch (error) {
+      this.logger.error(
+        `Failed to get topic info for ${hrlOrTopicId}: ${error.message}`
+      );
+      const hrl = `hcs://1/${hrlOrTopicId}`;
+      return this.resolveHRL(hrl, options);
+    }
+  }
+  async getContentWithType(hrl, options) {
+    if (!this.isValidHRL(hrl)) {
+      return {
+        content: hrl,
+        contentType: "text/plain",
+        isBinary: false
+      };
+    }
+    try {
+      const result = await this.resolveHRL(hrl, options);
+      return {
+        content: result.content,
+        contentType: result.contentType,
+        isBinary: result.isBinary
+      };
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL for content and type: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
+  /**
+   * Resolves HRL content with proper content type detection
+   */
+  async resolveHRL(hrl, options) {
+    const parsed = this.parseHRL(hrl);
+    if (!parsed) {
+      throw new Error(`Invalid HRL format: ${hrl}`);
+    }
+    const { standard, topicId } = parsed;
+    this.logger.debug(
+      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`
+    );
+    try {
+      const cdnEndpoint = options.cdnEndpoint || this.defaultEndpoint;
+      const cdnUrl = `${cdnEndpoint}/${topicId}?network=${options.network}`;
+      this.logger.debug(`Fetching content from CDN: ${cdnUrl}`);
+      const headResponse = await axios.head(cdnUrl);
+      const contentType = headResponse.headers["content-type"] || "";
+      const isBinary = this.isBinaryContentType(contentType);
+      if (isBinary || options.returnRaw) {
+        const response2 = await axios.get(cdnUrl, {
+          responseType: "arraybuffer"
+        });
+        return {
+          content: response2.data,
+          contentType,
+          topicId,
+          isBinary: true
+        };
+      }
+      if (contentType === "application/json") {
+        const response2 = await axios.get(cdnUrl, {
+          responseType: "json"
+        });
+        if (!response2.data) {
+          throw new Error(`Failed to fetch content from topic: ${topicId}`);
+        }
+        return {
+          content: response2.data,
+          contentType,
+          topicId,
+          isBinary: false
+        };
+      }
+      const response = await axios.get(cdnUrl);
+      if (!response.data) {
+        throw new Error(`Failed to fetch content from topic: ${topicId}`);
+      }
+      let content;
+      if (typeof response.data === "object") {
+        content = response.data.content || response.data.text || JSON.stringify(response.data);
+      } else {
+        content = response.data;
+      }
+      return {
+        content,
+        contentType,
+        topicId,
+        isBinary: false
+      };
+    } catch (e) {
+      const error = e;
+      const logMessage = `Error resolving HRL reference: ${error.message}`;
+      this.logger.error(logMessage);
+      throw new Error(logMessage);
+    }
+  }
 }
 export {
-  getTopicId
+  HRLResolver
 };
 //# sourceMappingURL=standards-sdk.es127.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es127.js","sources":["../../src/utils/topic-id-utils.ts"],"sourcesContent":["/**\n * Utility functions for safely handling topic ID properties that may use different naming conventions\n */\n\n/**\n * Safely extracts topic ID from an inscription result object that may have either `topicId` or `topic_id`\n * @param inscription - The inscription result object\n * @returns The topic ID string or undefined if not found\n */\ntype TopicIdCarrier =\n  | { topicId?: string; topic_id?: string }\n  | Record<string, unknown>\n  | null\n  | undefined;\n\nexport function getTopicId(inscription: unknown): string | undefined {\n  if (!inscription || typeof inscription !== 'object') return undefined;\n  const obj = inscription as TopicIdCarrier;\n  const direct =\n    (obj as { topicId?: string }).topicId ||\n    (obj as { topic_id?: string }).topic_id;\n  if (typeof direct === 'string' && direct.trim()) return direct;\n  const rec = obj as Record<string, unknown>;\n  const t1 = rec['topicId'];\n  if (typeof t1 === 'string' && t1.trim()) return t1;\n  const t2 = rec['topic_id'];\n  if (typeof t2 === 'string' && t2.trim()) return t2;\n  return undefined;\n}\n"],"names":[],"mappings":"AAeO,SAAS,WAAW,aAA0C;AACnE,MAAI,CAAC,eAAe,OAAO,gBAAgB,SAAU,QAAO;AAC5D,QAAM,MAAM;AACZ,QAAM,SACH,IAA6B,WAC7B,IAA8B;AACjC,MAAI,OAAO,WAAW,YAAY,OAAO,KAAA,EAAQ,QAAO;AACxD,QAAM,MAAM;AACZ,QAAM,KAAK,IAAI,SAAS;AACxB,MAAI,OAAO,OAAO,YAAY,GAAG,KAAA,EAAQ,QAAO;AAChD,QAAM,KAAK,IAAI,UAAU;AACzB,MAAI,OAAO,OAAO,YAAY,GAAG,KAAA,EAAQ,QAAO;AAChD,SAAO;AACT;"}
+{"version":3,"file":"standards-sdk.es127.js","sources":["../../src/utils/hrl-resolver.ts"],"sourcesContent":["import axios from 'axios';\nimport { Logger, LogLevel, ILogger } from './logger';\nimport { NetworkType } from './types';\nimport { HederaMirrorNode } from '../services';\n\n/**\n * Options for HRL resolution\n */\nexport interface HRLResolutionOptions {\n  network: NetworkType;\n  returnRaw?: boolean;\n  cdnEndpoint?: string;\n}\n\n/**\n * Result of an HRL resolution operation\n */\nexport interface HRLResolutionResult {\n  content: string | ArrayBuffer;\n  contentType: string;\n  topicId: string;\n  isBinary: boolean;\n}\n\nexport interface ContentWithType {\n  content: string | ArrayBuffer;\n  contentType: string;\n  isBinary: boolean;\n}\n\n/**\n * Utility class for resolving Hedera Resource Locators across the SDK\n */\nexport class HRLResolver {\n  private logger: ILogger;\n  private defaultEndpoint = 'https://kiloscribe.com/api/inscription-cdn';\n\n  constructor(logLevel: LogLevel = 'info') {\n    this.logger = Logger.getInstance({\n      level: logLevel,\n      module: 'HRLResolver',\n    });\n  }\n\n  /**\n   * Determines if a MIME type represents binary content\n   */\n  private isBinaryContentType(mimeType: string): boolean {\n    const binaryTypes = [\n      'image/',\n      'audio/',\n      'video/',\n      'application/octet-stream',\n      'application/pdf',\n      'application/zip',\n      'application/gzip',\n      'application/x-binary',\n      'application/vnd.ms-',\n      'application/x-msdownload',\n      'application/x-shockwave-flash',\n      'font/',\n      'application/wasm',\n    ];\n\n    return binaryTypes.some(prefix => mimeType.startsWith(prefix));\n  }\n\n  /**\n   * Parses an HRL string into its components\n   */\n  public parseHRL(hrl: string): { standard: string; topicId: string } | null {\n    if (!hrl) {\n      return null;\n    }\n\n    const hrlPattern = /^hcs:\\/\\/(\\d+)\\/([0-9]+\\.[0-9]+\\.[0-9]+)$/;\n    const match = hrl.match(hrlPattern);\n\n    if (!match) {\n      return null;\n    }\n\n    return {\n      standard: match[1],\n      topicId: match[2],\n    };\n  }\n\n  /**\n   * Validates if a string is a valid HRL\n   */\n  public isValidHRL(hrl: string): boolean {\n    if (!hrl || typeof hrl !== 'string') {\n      return false;\n    }\n\n    const parsed = this.parseHRL(hrl);\n    if (!parsed) {\n      return false;\n    }\n\n    const topicIdPattern = /^[0-9]+\\.[0-9]+\\.[0-9]+$/;\n    if (!topicIdPattern.test(parsed.topicId)) {\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Validates if a string is a valid topic ID\n   */\n  public isValidTopicId(topicId: string): boolean {\n    const topicIdPattern = /^[0-9]+\\.[0-9]+\\.[0-9]+$/;\n    return topicIdPattern.test(topicId);\n  }\n\n  /**\n   * Resolves content from either an HRL or a topic ID\n   * If a topic ID is provided, it queries the topic memo to determine the HCS standard\n   */\n  public async resolve(\n    hrlOrTopicId: string,\n    options: HRLResolutionOptions,\n  ): Promise<HRLResolutionResult> {\n    if (this.isValidHRL(hrlOrTopicId)) {\n      return this.resolveHRL(hrlOrTopicId, options);\n    }\n\n    if (!this.isValidTopicId(hrlOrTopicId)) {\n      throw new Error(`Invalid HRL or topic ID format: ${hrlOrTopicId}`);\n    }\n\n    try {\n      const mirrorNode = new HederaMirrorNode(options.network, this.logger);\n      const topicInfo = await mirrorNode.getTopicInfo(hrlOrTopicId);\n      const memo = topicInfo?.memo || '';\n\n      let standard = '1';\n      if (memo) {\n        const hcsMatch = memo.match(/^hcs-(\\d+)/);\n        if (hcsMatch && hcsMatch[1]) {\n          standard = hcsMatch[1];\n        }\n      }\n\n      const hrl = `hcs://${standard}/${hrlOrTopicId}`;\n      return this.resolveHRL(hrl, options);\n    } catch (error: any) {\n      this.logger.error(\n        `Failed to get topic info for ${hrlOrTopicId}: ${error.message}`,\n      );\n      const hrl = `hcs://1/${hrlOrTopicId}`;\n      return this.resolveHRL(hrl, options);\n    }\n  }\n\n  public async getContentWithType(\n    hrl: string,\n    options: HRLResolutionOptions,\n  ): Promise<ContentWithType> {\n    if (!this.isValidHRL(hrl)) {\n      return {\n        content: hrl,\n        contentType: 'text/plain',\n        isBinary: false,\n      };\n    }\n\n    try {\n      const result = await this.resolveHRL(hrl, options);\n      return {\n        content: result.content,\n        contentType: result.contentType,\n        isBinary: result.isBinary,\n      };\n    } catch (e: any) {\n      const error = e as Error;\n      const logMessage = `Error resolving HRL for content and type: ${error.message}`;\n      this.logger.error(logMessage);\n      throw new Error(logMessage);\n    }\n  }\n\n  /**\n   * Resolves HRL content with proper content type detection\n   */\n  public async resolveHRL(\n    hrl: string,\n    options: HRLResolutionOptions,\n  ): Promise<HRLResolutionResult> {\n    const parsed = this.parseHRL(hrl);\n\n    if (!parsed) {\n      throw new Error(`Invalid HRL format: ${hrl}`);\n    }\n\n    const { standard, topicId } = parsed;\n\n    this.logger.debug(\n      `Resolving HRL reference: standard=${standard}, topicId=${topicId}`,\n    );\n\n    try {\n      const cdnEndpoint = options.cdnEndpoint || this.defaultEndpoint;\n      const cdnUrl = `${cdnEndpoint}/${topicId}?network=${options.network}`;\n\n      this.logger.debug(`Fetching content from CDN: ${cdnUrl}`);\n      const headResponse = await axios.head(cdnUrl);\n      const contentType = headResponse.headers['content-type'] || '';\n      const isBinary = this.isBinaryContentType(contentType);\n\n      if (isBinary || options.returnRaw) {\n        const response = await axios.get(cdnUrl, {\n          responseType: 'arraybuffer',\n        });\n\n        return {\n          content: response.data,\n          contentType,\n          topicId,\n          isBinary: true,\n        };\n      }\n\n      if (contentType === 'application/json') {\n        const response = await axios.get(cdnUrl, {\n          responseType: 'json',\n        });\n\n        if (!response.data) {\n          throw new Error(`Failed to fetch content from topic: ${topicId}`);\n        }\n\n        return {\n          content: response.data,\n          contentType,\n          topicId,\n          isBinary: false,\n        };\n      }\n\n      const response = await axios.get(cdnUrl);\n\n      if (!response.data) {\n        throw new Error(`Failed to fetch content from topic: ${topicId}`);\n      }\n\n      let content: string;\n\n      if (typeof response.data === 'object') {\n        content =\n          response.data.content ||\n          response.data.text ||\n          JSON.stringify(response.data);\n      } else {\n        content = response.data;\n      }\n\n      return {\n        content,\n        contentType,\n        topicId,\n        isBinary: false,\n      };\n    } catch (e: any) {\n      const error = e as Error;\n      const logMessage = `Error resolving HRL reference: ${error.message}`;\n      this.logger.error(logMessage);\n      throw new Error(logMessage);\n    }\n  }\n}\n"],"names":["response"],"mappings":"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"}