@hashgraphonline/standards-sdk 0.1.144 → 0.1.146-chore-jsr-improvements.canary.74bacb9.89

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

@@ -1,605 +1,16 @@
-import { PrivateKey } from "@hashgraph/sdk";
-var KeyType = /* @__PURE__ */ ((KeyType2) => {
-  KeyType2["ED25519"] = "ed25519";
-  KeyType2["ECDSA"] = "ecdsa";
-  KeyType2["UNKNOWN"] = "unknown";
-  return KeyType2;
-})(KeyType || {});
-const _KeyTypeDetector = class _KeyTypeDetector {
-  /**
-   * Detects private key type from various input formats without throwing errors
-   *
-   * This detector is designed for private keys only. It uses various heuristics to determine
-   * the key type for ambiguous 32-byte keys, including byte patterns and statistical analysis.
-   *
-   * For ambiguous cases (where confidence is 'uncertain'), if you have the associated account ID,
-   * you can use the Hedera mirror node to confirm the key type.
-   *
-   * @param keyInput - The key to detect, can be a string (hex, base64, PEM), Buffer, or Uint8Array
-   * @returns KeyInfo object containing the detected key type and metadata
-   *
-   * @example
-   * // Detect from hex string
-   * const info1 = KeyTypeDetector.detect('0x7f96cea0c0d9d5bfb3ab8a42cf0cea44d57f62f2e068f8e5a3251914a9252b04');
-   *
-   * // Detect from DER-encoded string
-   * const info2 = KeyTypeDetector.detect(privateKey.toStringDer());
-   *
-   * // Detect from PEM format
-   * const info3 = KeyTypeDetector.detect(`-----BEGIN PRIVATE KEY-----
-   * MC4CAQAwBQYDK2VwBCIEIGRchBsQGQduAAGBQ7GAkKCKkmQ3EGCARwHsHiRqTNR9
-   * -----END PRIVATE KEY-----`);
-   */
-  static detect(keyInput) {
-    try {
-      let keyBytes;
-      let originalFormat = "raw";
-      if (typeof keyInput === "string") {
-        let trimmed = keyInput.trim();
-        if (trimmed.includes("-----BEGIN")) {
-          return this.detectFromPem(trimmed);
-        }
-        if (trimmed.toLowerCase().startsWith("0x")) {
-          trimmed = trimmed.substring(2);
-        }
-        if (this.isValidHex(trimmed)) {
-          keyBytes = this.hexToBytes(trimmed);
-          originalFormat = "hex";
-        } else if (this.isBase64(trimmed)) {
-          keyBytes = Buffer.from(trimmed, "base64");
-          originalFormat = "der";
-        } else {
-          return {
-            type: "unknown",
-            format: "raw",
-            isPrivateKey: false,
-            confidence: "certain"
-          };
-        }
-      } else if (keyInput instanceof Buffer) {
-        keyBytes = new Uint8Array(keyInput);
-      } else {
-        keyBytes = keyInput;
-      }
-      return this.detectFromBytes(keyBytes, originalFormat);
-    } catch (error) {
-      return {
-        type: "unknown",
-        format: "raw",
-        isPrivateKey: false,
-        confidence: "certain"
-      };
-    }
-  }
-  /**
-   * Detect key type from raw bytes
-   *
-   * @param bytes - The raw bytes of the key
-   * @param format - The original format of the key
-   * @returns KeyInfo object with detection results
-   * @private
-   */
-  static detectFromBytes(bytes, format) {
-    if (this.hasPrefix(bytes, this.ED25519_PUBLIC_KEY_PREFIX)) {
-      const keyStart = this.ED25519_PUBLIC_KEY_PREFIX.length;
-      return {
-        type: "ed25519",
-        format: "der",
-        isPrivateKey: false,
-        rawBytes: bytes.slice(keyStart),
-        confidence: "certain"
-      };
-    }
-    if (this.hasPrefix(bytes, this.ED25519_PRIVATE_KEY_PREFIX)) {
-      const keyStart = this.ED25519_PRIVATE_KEY_PREFIX.length;
-      if (bytes.length >= keyStart + 32) {
-        return {
-          type: "ed25519",
-          format: "der",
-          isPrivateKey: true,
-          rawBytes: bytes.slice(keyStart, keyStart + 32),
-          confidence: "certain"
-        };
-      }
-    }
-    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX)) {
-      const keyStart = this.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX.length;
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: false,
-        rawBytes: bytes.slice(keyStart),
-        confidence: "certain"
-      };
-    }
-    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT)) {
-      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT.length;
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: true,
-        rawBytes: bytes.slice(keyStart),
-        confidence: "certain"
-      };
-    }
-    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX)) {
-      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX.length;
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: true,
-        rawBytes: bytes.slice(keyStart, keyStart + 32),
-        confidence: "certain"
-      };
-    }
-    if (this.hasPrefix(bytes, this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG)) {
-      const keyStart = this.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG.length;
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: true,
-        rawBytes: bytes.slice(keyStart, keyStart + 32),
-        confidence: "certain"
-      };
-    }
-    if (bytes.length > 36 && this.containsECDSAPrivateKeyPattern(bytes)) {
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: true,
-        rawBytes: this.extractECDSAPrivateKey(bytes),
-        confidence: "certain"
-      };
-    }
-    switch (bytes.length) {
-      case this.ED25519_PUBLIC_KEY_LENGTH:
-        if (format === "hex") {
-          const hexStr = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-          const privateResult = this.tryCreateKey(hexStr);
-          if (privateResult.type !== "unknown") {
-            return privateResult;
-          }
-        }
-        return {
-          type: "unknown",
-          format,
-          isPrivateKey: false,
-          rawBytes: bytes,
-          confidence: "certain"
-        };
-      case this.ED25519_EXPANDED_PRIVATE_KEY_LENGTH:
-        return {
-          type: "ed25519",
-          format,
-          isPrivateKey: true,
-          rawBytes: bytes,
-          confidence: "certain"
-        };
-    }
-    return {
-      type: "unknown",
-      format,
-      isPrivateKey: false,
-      rawBytes: bytes,
-      confidence: "certain"
-    };
-  }
-  /**
-   * Detect key type from PEM format
-   *
-   * @param pem - The PEM-encoded key string
-   * @returns KeyInfo object with detection results
-   * @private
-   */
-  static detectFromPem(pem) {
-    const trimmedPem = pem.trim();
-    const isPrivateKey = trimmedPem.includes("PRIVATE KEY");
-    const pemTypes = {
-      EC_PRIVATE: /-----BEGIN EC PRIVATE KEY-----/,
-      EC_PUBLIC: /-----BEGIN EC PUBLIC KEY-----/,
-      PRIVATE: /-----BEGIN PRIVATE KEY-----/,
-      PUBLIC: /-----BEGIN PUBLIC KEY-----/
-    };
-    let isECKey = false;
-    for (const [type, regex] of Object.entries(pemTypes)) {
-      if (regex.test(trimmedPem) && type.includes("EC")) {
-        isECKey = true;
-        break;
-      }
-    }
-    const base64Match = trimmedPem.match(
-      /-----BEGIN[\s\S]+?-----[\r\n]+([\s\S]+?)[\r\n]+-----END/
-    );
-    if (!base64Match) {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-    const base64Content = base64Match[1].replace(/\s/g, "");
-    try {
-      const derBytes = Buffer.from(base64Content, "base64");
-      const result = this.detectFromBytes(new Uint8Array(derBytes), "der");
-      if (result.type === "unknown" && isECKey) {
-        return {
-          type: "ecdsa",
-          format: "pem",
-          isPrivateKey,
-          rawBytes: derBytes,
-          confidence: "certain"
-        };
-      }
-      return {
-        ...result,
-        format: "pem"
-      };
-    } catch {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-  }
-  /**
-   * Try to create a key using Hedera SDK to validate the type
-   *
-   * @param keyInput - The key input string or bytes
-   * @returns KeyInfo object with detection results
-   * @private
-   */
-  static tryCreateKey(keyInput) {
-    try {
-      if (typeof keyInput === "string") {
-        let keyStr = keyInput.trim();
-        if (keyStr.toLowerCase().startsWith("0x")) {
-          keyStr = keyStr.substring(2);
-        }
-        if (this.isValidHex(keyStr) && keyStr.length === 64) {
-          const keyBytes = this.hexToBytes(keyStr);
-          const signatureResult = this.detectBySignature(keyStr);
-          if (signatureResult.type !== "unknown") {
-            return {
-              type: signatureResult.type,
-              format: "hex",
-              isPrivateKey: true,
-              rawBytes: keyBytes,
-              confidence: signatureResult.confidence,
-              warning: signatureResult.warning
-            };
-          }
-          return {
-            type: "unknown",
-            format: "hex",
-            isPrivateKey: false,
-            rawBytes: keyBytes,
-            confidence: "certain"
-          };
-        }
-      }
-    } catch {
-    }
-    return {
-      type: "unknown",
-      format: "hex",
-      isPrivateKey: false,
-      rawBytes: new Uint8Array(),
-      confidence: "certain"
-    };
-  }
-  /**
-   * Detect key type by attempting to sign a message with both algorithms
-   *
-   * For ambiguous cases where both algorithms can use the key, this method
-   * uses heuristics to make a best-effort determination. For production use
-   * with ambiguous keys, consider using the Hedera mirror node to confirm
-   * the key type if you have the associated account ID.
-   *
-   * @param hexKey - The hex string representation of the key
-   * @returns Object containing type, confidence level, and optional warning
-   * @private
-   */
-  static detectBySignature(hexKey) {
-    const keyBigInt = BigInt("0x" + hexKey);
-    const secp256k1Order = BigInt(
-      "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
-    );
-    if (keyBigInt === 0n) {
-      return {
-        type: "ed25519",
-        confidence: "certain"
-      };
-    }
-    if (keyBigInt >= secp256k1Order) {
-      return {
-        type: "ed25519",
-        confidence: "certain"
-      };
-    }
-    let ed25519CanSign = false;
-    let ecdsaCanSign = false;
-    try {
-      const ed25519Key = PrivateKey.fromStringED25519(hexKey);
-      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);
-      const signature = ed25519Key.sign(testMessage);
-      if (ed25519Key.publicKey.verify(testMessage, signature)) {
-        ed25519CanSign = true;
-      }
-    } catch {
-    }
-    try {
-      const ecdsaKey = PrivateKey.fromStringECDSA(hexKey);
-      const testMessage = new Uint8Array([1, 2, 3, 4, 5]);
-      const signature = ecdsaKey.sign(testMessage);
-      if (ecdsaKey.publicKey.verify(testMessage, signature)) {
-        ecdsaCanSign = true;
-      }
-    } catch {
-    }
-    if (ed25519CanSign && ecdsaCanSign) {
-      const keyBytes = this.hexToBytes(hexKey);
-      if (keyBytes[0] === 168 && keyBytes[1] === 1) {
-        return {
-          type: "ed25519",
-          confidence: "uncertain",
-          warning: "Detection based on byte pattern heuristic. Both ED25519 and ECDSA accept this key."
-        };
-      }
-      let highBytes = 0;
-      for (const byte of keyBytes) {
-        if (byte >= 128) highBytes++;
-      }
-      const highByteRatio = highBytes / keyBytes.length;
-      if (highByteRatio >= 0.4 && highByteRatio <= 0.6) {
-        return {
-          type: "ecdsa",
-          confidence: "uncertain",
-          warning: "Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key."
-        };
-      }
-      return {
-        type: "ecdsa",
-        confidence: "uncertain",
-        warning: "Detection based on entropy heuristic. Both ED25519 and ECDSA accept this key. Defaulting to ECDSA."
-      };
-    }
-    if (ed25519CanSign && !ecdsaCanSign) {
-      return {
-        type: "ed25519",
-        confidence: "certain"
-      };
-    }
-    if (ecdsaCanSign && !ed25519CanSign) {
-      return {
-        type: "ecdsa",
-        confidence: "certain"
-      };
-    }
-    return {
-      type: "unknown",
-      confidence: "certain"
-    };
-  }
-  /**
-   * Check if a string is valid hexadecimal with even length
-   *
-   * @param str - The string to check
-   * @returns True if the string is valid hex with even length
-   * @private
-   */
-  static isValidHex(str) {
-    return /^[0-9a-fA-F]+$/.test(str) && str.length % 2 === 0;
-  }
-  /**
-   * Check if a string is valid base64
-   *
-   * @param str - The string to check
-   * @returns True if the string is valid base64
-   * @private
-   */
-  static isBase64(str) {
-    try {
-      return Buffer.from(str, "base64").toString("base64") === str;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Convert a hex string to bytes
-   *
-   * @param hex - The hex string to convert
-   * @returns Uint8Array of bytes
-   * @private
-   */
-  static hexToBytes(hex) {
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-    }
-    return bytes;
-  }
-  /**
-   * Check if bytes start with a specific prefix
-   *
-   * @param bytes - The bytes to check
-   * @param prefix - The prefix to look for
-   * @returns True if bytes start with the prefix
-   * @private
-   */
-  static hasPrefix(bytes, prefix) {
-    if (bytes.length < prefix.length) return false;
-    for (let i = 0; i < prefix.length; i++) {
-      if (bytes[i] !== prefix[i]) return false;
-    }
-    return true;
-  }
-  /**
-   * Check if bytes contain an ECDSA private key pattern
-   *
-   * @param bytes - The bytes to check
-   * @returns True if ECDSA private key pattern is found
-   * @private
-   */
-  static containsECDSAPrivateKeyPattern(bytes) {
-    for (let i = 0; i < bytes.length - 7; i++) {
-      if (bytes[i] === 48 && bytes[i + 1] === 116 && bytes[i + 2] === 2 && bytes[i + 3] === 1 && bytes[i + 4] === 1 && bytes[i + 5] === 4 && bytes[i + 6] === 32) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Extract ECDSA private key from DER structure
-   *
-   * @param bytes - The DER encoded bytes
-   * @returns The extracted private key bytes
-   * @private
-   */
-  static extractECDSAPrivateKey(bytes) {
-    for (let i = 0; i < bytes.length - 32; i++) {
-      if (bytes[i] === 4 && bytes[i + 1] === 32) {
-        return bytes.slice(i + 2, i + 34);
-      }
-    }
-    return bytes;
-  }
-};
-_KeyTypeDetector.ED25519_PUBLIC_KEY_LENGTH = 32;
-_KeyTypeDetector.ED25519_EXPANDED_PRIVATE_KEY_LENGTH = 64;
-_KeyTypeDetector.ED25519_PUBLIC_KEY_PREFIX = Buffer.from([
-  48,
-  42,
-  48,
-  5,
-  6,
-  3,
-  43,
-  101,
-  112,
-  3,
-  33,
-  0
-]);
-_KeyTypeDetector.ED25519_PRIVATE_KEY_PREFIX = Buffer.from([
-  48,
-  46,
-  2,
-  1,
-  0,
-  48,
-  5,
-  6,
-  3,
-  43,
-  101,
-  112,
-  4,
-  34,
-  4,
-  32
-]);
-_KeyTypeDetector.ECDSA_SECP256K1_PUBLIC_KEY_PREFIX = Buffer.from([
-  48,
-  86,
-  48,
-  16,
-  6,
-  7,
-  42,
-  134,
-  72,
-  206,
-  61,
-  2,
-  1,
-  6,
-  5,
-  43,
-  129,
-  4,
-  0,
-  10,
-  3,
-  66,
-  0
-]);
-_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX = Buffer.from([
-  48,
-  116,
-  2,
-  1,
-  1,
-  4,
-  32
-]);
-_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_SHORT = Buffer.from([
-  48,
-  48,
-  2,
-  1,
-  0,
-  48,
-  7,
-  6,
-  5,
-  43,
-  129,
-  4,
-  0,
-  10,
-  4,
-  34,
-  4,
-  32
-]);
-_KeyTypeDetector.ECDSA_SECP256K1_PRIVATE_KEY_PREFIX_LONG = Buffer.from(
-  [48, 119, 2, 1, 1, 4, 32]
-);
-let KeyTypeDetector = _KeyTypeDetector;
-function detectKeyTypeFromString(privateKeyString) {
-  const keyInfo = KeyTypeDetector.detect(privateKeyString);
-  if (keyInfo.type !== "unknown") {
-    try {
-      const privateKey = keyInfo.type === "ecdsa" ? PrivateKey.fromStringECDSA(privateKeyString) : PrivateKey.fromStringED25519(privateKeyString);
-      const result = {
-        detectedType: keyInfo.type,
-        privateKey
-      };
-      if (keyInfo.confidence === "uncertain") {
-        result.warning = `Key type detection is uncertain. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`;
-      }
-      return result;
-    } catch (error) {
-    }
-  }
-  try {
-    const privateKey = PrivateKey.fromStringECDSA(privateKeyString);
-    return {
-      detectedType: "ecdsa",
-      privateKey,
-      warning: `Using ECDSA as default. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`
-    };
-  } catch (ecdsaError) {
-    try {
-      const privateKey = PrivateKey.fromStringED25519(privateKeyString);
-      return {
-        detectedType: "ed25519",
-        privateKey,
-        warning: `Using ED25519 as fallback. If you have the associated account ID, consider using the Hedera mirror node to confirm the key type.`
-      };
-    } catch (ed25519Error) {
-      throw new Error(
-        `Failed to parse private key as either ECDSA or ED25519: ${ecdsaError}`
-      );
-    }
-  }
+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;
 }
 export {
-  KeyType,
-  KeyTypeDetector,
-  detectKeyTypeFromString
+  getTopicId
 };
 //# sourceMappingURL=standards-sdk.es114.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es114.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.es114.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;"}