@hashgraphonline/standards-sdk 0.1.188 → 0.1.190

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

@@ -1,629 +1,254 @@
-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"
-      };
+import { readSubjectAdditional, readString } from "./standards-sdk.es198.js";
+import "./standards-sdk.es182.js";
+import "./standards-sdk.es195.js";
+import "./standards-sdk.es196.js";
+import "./standards-sdk.es197.js";
+import { parseTimestampMs } from "./standards-sdk.es123.js";
+import { requestJson, Hcs25CollectorHttpError, isTimeoutError } from "./standards-sdk.es122.js";
+const AGENTVERSE_API_BASE = "https://agentverse.ai";
+const INSIGHTS_SOURCES = ["agentverse:insights:v1"];
+const AGENTVERSE_ADDRESS_REGEX = /^agent1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{59}$/i;
+const DEFAULT_INCLUDED_REGISTRIES = ["agentverse", "uagent"];
+function resolveAgentAddress(subject) {
+  const additional = readSubjectAdditional(subject);
+  const metadata = subject.metadata ?? {};
+  for (const value of [
+    readString(additional, "agentverseInsightsAddress"),
+    subject.id,
+    readString(metadata, "nativeId"),
+    readString(metadata, "uid"),
+    readString(metadata, "address")
+  ]) {
+    if (value && AGENTVERSE_ADDRESS_REGEX.test(value.trim())) {
+      return value.trim();
     }
   }
-  /**
-   * 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"
-      };
+  const uaidFull = readString(metadata, "uaidFull");
+  if (uaidFull) {
+    const nativeId = uaidFull.match(/(?:^|;)nativeId=([^;]+)(?:;|$)/i)?.[1]?.trim();
+    if (nativeId && AGENTVERSE_ADDRESS_REGEX.test(nativeId)) {
+      return nativeId;
     }
-    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"
-      };
+    const uid = uaidFull.match(/(?:^|;)uid=([^;]+)(?:;|$)/i)?.[1]?.trim();
+    if (uid && AGENTVERSE_ADDRESS_REGEX.test(uid)) {
+      return uid;
     }
-    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"
-      };
+  }
+  return null;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function createAgentverseInsightsSignalAdapter(options = {}) {
+  const baseUrl = options.baseUrl ?? AGENTVERSE_API_BASE;
+  const fetchAgentStatus = options.fetchAgentStatus ?? true;
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const address = resolveAgentAddress(subject);
+    if (!address) {
+      return [
+        {
+          signalId: "agentverse.insights",
+          status: "missing",
+          fields: [
+            {
+              scope: "additional",
+              values: {
+                agentverseInsightsStatus: "missing",
+                agentverseInsightsUpdatedAt: now
+              }
+            }
+          ]
+        }
+      ];
     }
-    if (bytes.length > 36 && this.containsECDSAPrivateKeyPattern(bytes)) {
-      return {
-        type: "ecdsa",
-        format: "der",
-        isPrivateKey: true,
-        rawBytes: this.extractECDSAPrivateKey(bytes),
-        confidence: "certain"
-      };
+    if (!context.force) {
+      const additional = readSubjectAdditional(subject);
+      const storedStatus = readString(additional, "agentverseInsightsStatus");
+      const storedUpdatedMs = parseTimestampMs(
+        additional.agentverseInsightsUpdatedAt
+      );
+      if (storedStatus && storedUpdatedMs !== null) {
+        const ttl = storedStatus === "ok" ? options.ttlMs ?? 6 * 60 * 60 * 1e3 : options.failureTtlMs ?? 60 * 60 * 1e3;
+        if (context.now.getTime() - storedUpdatedMs < ttl) {
+          return [
+            {
+              signalId: "agentverse.insights",
+              status: storedStatus === "ok" ? "ok" : "missing",
+              provenance: {
+                source: "agentverse",
+                subjectId: address,
+                fetchedAt: new Date(storedUpdatedMs).toISOString()
+              }
+            }
+          ];
+        }
+      }
     }
-    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;
+    const results = [];
+    const sources = [];
+    const contractParam = options.contract ?? readString(readSubjectAdditional(subject), "agentverseInsightsContract");
+    const contractsToTry = contractParam === "mainnet" || contractParam === "testnet" ? [contractParam] : ["mainnet", "testnet"];
+    let insightsResult = { status: "missing" };
+    for (const contract of contractsToTry) {
+      const insightsUrl = `${baseUrl}/v1/search/analytics/insights/${encodeURIComponent(address)}?contract=${contract}`;
+      try {
+        const data = await requestJson(
+          insightsUrl,
+          {
+            fetch: context.fetch,
+            timeoutMs: context.timeoutMs,
+            signal: context.signal
           }
+        );
+        const hasAnySignal = num(data.rating) !== null || num(data.readme_quality_score) !== null || num(data.readme_uniqueness_score) !== null || num(data.interactions_score) !== null || num(data.avg_response_time) !== null || (num(data.asi1_total_interactions) ?? 0) > 0 || (num(data.asi1_recent_interactions) ?? 0) > 0 || (num(data.verifier_total_interactions) ?? 0) > 0 || (num(data.verifier_recent_interactions) ?? 0) > 0;
+        if (!hasAnySignal) {
+          continue;
         }
-        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;
+        insightsResult = { data, contract, url: insightsUrl };
         break;
-      }
-    }
-    const beginMarkerIndex = trimmedPem.indexOf("-----BEGIN ");
-    if (beginMarkerIndex === -1) {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-    const beginLineEndIndex = trimmedPem.indexOf("\n", beginMarkerIndex);
-    if (beginLineEndIndex === -1) {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-    const endMarkerIndex = trimmedPem.lastIndexOf("-----END ");
-    if (endMarkerIndex === -1 || endMarkerIndex <= beginLineEndIndex) {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-    const base64Content = trimmedPem.slice(beginLineEndIndex + 1, endMarkerIndex).replace(/\s/g, "");
-    if (!base64Content) {
-      return {
-        type: "unknown",
-        format: "pem",
-        isPrivateKey,
-        confidence: "certain"
-      };
-    }
-    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"
+      } catch (error) {
+        if (error instanceof Hcs25CollectorHttpError && (error.status === 404 || error.status === 422)) {
+          continue;
+        }
+        insightsResult = {
+          status: isTimeoutError(error) ? "timeout" : "upstream-error"
         };
+        break;
       }
-      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 ("data" in insightsResult) {
+      const { data, contract, url } = insightsResult;
+      sources.push("insights");
+      results.push({
+        signalId: "agentverse.insights",
+        status: "ok",
+        value: num(data.rating),
+        fields: [
+          {
+            scope: "additional",
+            values: {
+              agentverseInsightsUpdatedAt: now,
+              agentverseInsightsStatus: "ok",
+              agentverseInsightsAddress: address,
+              agentverseInsightsContract: contract,
+              agentverseInsightsSources: [...INSIGHTS_SOURCES],
+              agentverseInsightsRating: num(data.rating),
+              agentverseInsightsReadmeQualityScore: num(
+                data.readme_quality_score
+              ),
+              agentverseInsightsReadmeUniquenessScore: num(
+                data.readme_uniqueness_score
+              ),
+              agentverseInsightsInteractionsScore: num(data.interactions_score),
+              agentverseInsightsAvgResponseTime: num(data.avg_response_time),
+              agentverseInsightsAsi1TotalInteractions: num(data.asi1_total_interactions) ?? 0,
+              agentverseInsightsAsi1TotalSuccessInteractions: num(data.asi1_total_success_interactions) ?? 0,
+              agentverseInsightsAsi1RecentInteractions: num(data.asi1_recent_interactions) ?? 0,
+              agentverseInsightsAsi1RecentSuccessInteractions: num(data.asi1_recent_success_interactions) ?? 0,
+              agentverseInsightsVerifierTotalInteractions: num(data.verifier_total_interactions) ?? 0,
+              agentverseInsightsVerifierTotalSuccessInteractions: num(data.verifier_total_success_interactions) ?? 0,
+              agentverseInsightsVerifierRecentInteractions: num(data.verifier_recent_interactions) ?? 0,
+              agentverseInsightsVerifierRecentSuccessInteractions: num(data.verifier_recent_success_interactions) ?? 0
+            }
+          }
+        ],
+        provenance: {
+          source: "agentverse",
+          sourceUrl: url,
+          subjectId: address,
+          fetchedAt: now
         }
-        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
-            };
+      });
+    } else {
+      const stored = insightsResult.status === "missing" ? "missing" : "upstream-error";
+      results.push({
+        signalId: "agentverse.insights",
+        status: insightsResult.status === "timeout" ? "timeout" : stored === "missing" ? "missing" : "error",
+        fields: [
+          {
+            scope: "additional",
+            values: {
+              agentverseInsightsUpdatedAt: now,
+              agentverseInsightsStatus: stored,
+              agentverseInsightsAddress: address,
+              agentverseInsightsSources: [...INSIGHTS_SOURCES]
+            }
           }
-          return {
-            type: "unknown",
-            format: "hex",
-            isPrivateKey: false,
-            rawBytes: keyBytes,
-            confidence: "certain"
-          };
+        ],
+        provenance: {
+          source: "agentverse",
+          subjectId: address,
+          fetchedAt: now
         }
+      });
+    }
+    if (fetchAgentStatus) {
+      const agentUrl = `${baseUrl}/v1/search/agents/${encodeURIComponent(address)}${contractParam ? `?contract=${contractParam}` : ""}`;
+      try {
+        const agent = await requestJson(agentUrl, {
+          fetch: context.fetch,
+          timeoutMs: context.timeoutMs,
+          signal: context.signal
+        });
+        sources.push("search-agent");
+        results.push({
+          signalId: "agentverse.agent_status",
+          status: "ok",
+          value: agent.status ?? null,
+          fields: [
+            {
+              scope: "metrics",
+              values: {
+                isOnline: agent.status === "active",
+                lastActiveAt: agent.last_updated ?? null
+              }
+            }
+          ],
+          provenance: {
+            source: "agentverse",
+            sourceUrl: agentUrl,
+            subjectId: address,
+            fetchedAt: now
+          }
+        });
+      } catch {
+        results.push({
+          signalId: "agentverse.agent_status",
+          status: "missing"
+        });
       }
-    } 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}`
-      );
     }
-  }
+    if (sources.length > 0) {
+      results.push({
+        signalId: "agentverse.sources",
+        status: "ok",
+        value: sources,
+        fields: [
+          {
+            scope: "additional",
+            values: { agentverseInsightsSources: sources }
+          }
+        ]
+      });
+    }
+    return results;
+  };
+  return {
+    id: "agentverse-insights",
+    produces: [
+      "agentverse.insights",
+      "agentverse.agent_status",
+      "agentverse.sources"
+    ],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_INCLUDED_REGISTRIES,
+    excludeRegistries: options.excludeRegistries,
+    appliesTo: options.appliesTo,
+    collect
+  };
 }
 export {
-  KeyType,
-  KeyTypeDetector,
-  detectKeyTypeFromString
+  createAgentverseInsightsSignalAdapter
 };
 //# sourceMappingURL=standards-sdk.es136.js.map