@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

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

@@ -1,793 +1,237 @@
-import { proto } from "@hashgraph/proto";
-import { Buffer } from "buffer";
-import { Hbar, Long, HbarUnit, Transaction } from "@hashgraph/sdk";
-import { ethers } from "ethers";
-import { TransactionParsingError } from "./standards-sdk.es134.js";
-import { resolveTransactionSummary } from "./standards-sdk.es135.js";
-import { HTSParser } from "./standards-sdk.es143.js";
-import { HCSParser } from "./standards-sdk.es191.js";
-import { FileParser } from "./standards-sdk.es192.js";
-import { CryptoParser } from "./standards-sdk.es193.js";
-import { SCSParser } from "./standards-sdk.es194.js";
-import { UtilParser } from "./standards-sdk.es195.js";
-import { ScheduleParser } from "./standards-sdk.es144.js";
-import { transactionParserRegistry } from "./standards-sdk.es145.js";
-import { getTransactionTypeFromBody, getHumanReadableTransactionType } from "./standards-sdk.es146.js";
-class TransactionParser {
-  /**
-   * Parse transaction bytes in any supported format (base64 or hex, regular or scheduled)
-   * This is the main entry point for transaction parsing with enhanced retry logic
-   *
-   * @param transactionBytes - Transaction bytes in base64 or hex format
-   * @param options - Parsing options and configuration
-   * @returns Promise resolving to ParsedTransaction
-   */
-  static async parseTransactionBytes(transactionBytes, options = {}) {
-    const {
-      enableFallback = true,
-      strictMode = false,
-      includeRaw = true,
-      maxRetries = 2
-    } = options;
-    const validation = this.validateTransactionBytes(transactionBytes);
-    if (!validation.isValid && strictMode) {
-      throw new TransactionParsingError(
-        `Invalid transaction bytes format: ${validation.error}`,
-        "INVALID_FORMAT",
-        void 0,
-        transactionBytes
-      );
-    }
-    let lastError;
-    let retryCount = 0;
-    while (retryCount <= maxRetries) {
-      try {
-        const result = await this.parseTransaction(transactionBytes, options);
-        result.formatDetection = {
-          originalFormat: validation.format || "base64",
-          wasConverted: validation.format === "hex",
-          length: transactionBytes.length
-        };
-        return result;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        retryCount++;
-        if (!enableFallback || retryCount > maxRetries) {
-          if (strictMode) {
-            throw new TransactionParsingError(
-              "Failed to parse transaction after all attempts",
-              "PARSING_FAILED",
-              lastError,
-              transactionBytes
-            );
-          }
-          break;
-        }
-        try {
-          const result = this.parseScheduledTransaction(
-            transactionBytes,
-            options
-          );
-          result.formatDetection = {
-            originalFormat: validation.format || "base64",
-            wasConverted: false,
-            length: transactionBytes.length
-          };
-          return result;
-        } catch (scheduledError) {
-        }
-      }
-    }
-    const fallbackResult = this.createFallbackResult(
-      transactionBytes,
-      lastError,
-      void 0
-    );
-    if (fallbackResult.details) {
-      fallbackResult.details.parseAttempts = Math.max(retryCount, 1);
-    }
-    return fallbackResult;
+import { readString } from "./standards-sdk.es201.js";
+import "./standards-sdk.es184.js";
+import "./standards-sdk.es198.js";
+import "./standards-sdk.es199.js";
+import "./standards-sdk.es200.js";
+import "./standards-sdk.es183.js";
+import { requestJson, Hcs25CollectorHttpError, isTimeoutError } from "./standards-sdk.es122.js";
+const parsePositiveInt = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+  }
+  return null;
+};
+const parseNonNegativeInt = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const normalized = Math.floor(value);
+    return normalized >= 0 ? normalized : null;
   }
-  /**
-   * Parse a Transaction object directly using unified delegation approach
-   * This method delegates to specialized parsers for clean separation of concerns
-   *
-   * @param transaction - The Transaction object to parse
-   * @param originalBytes - The original transaction bytes (optional, for protobuf parsing)
-   * @param options - Parsing options
-   * @returns Parsed transaction data
-   */
-  static parseTransactionObject(transaction, originalBytesOrOptions, options = {}) {
-    let originalBytes;
-    let actualOptions;
-    if (originalBytesOrOptions && !Buffer.isBuffer(originalBytesOrOptions) && !(originalBytesOrOptions instanceof Uint8Array)) {
-      actualOptions = originalBytesOrOptions;
-      originalBytes = void 0;
-    } else {
-      originalBytes = originalBytesOrOptions;
-      actualOptions = options;
-    }
-    try {
-      const metadata = this.extractTransactionMetadata(transaction);
-      const htsResult = HTSParser.parseFromTransactionObject(transaction);
-      const cryptoResult = CryptoParser.parseFromTransactionObject(transaction);
-      const hcsResult = HCSParser.parseFromTransactionObject(transaction);
-      const fileResult = FileParser.parseFromTransactionObject(transaction);
-      const scsResult = SCSParser.parseFromTransactionObject(transaction);
-      const scheduleResult = ScheduleParser.parseFromTransactionObject(transaction);
-      const utilResult = UtilParser.parseFromTransactionObject(transaction);
-      const results = [
-        htsResult,
-        cryptoResult,
-        hcsResult,
-        fileResult,
-        scsResult,
-        scheduleResult,
-        utilResult
-      ];
-      const primaryResult = results.find((result2) => result2.type && result2.type !== "UNKNOWN") || {};
-      let finalType = "UNKNOWN";
-      let finalHumanReadableType = "Unknown Transaction";
-      let parsedTokenCreation;
-      let protoParsingResult = {};
-      if (originalBytes || transaction.toBytes) {
-        try {
-          const bytesToParse = originalBytes || transaction.toBytes();
-          const decoded = proto.TransactionList.decode(bytesToParse);
-          if (decoded.transactionList && decoded.transactionList.length > 0) {
-            const tx = decoded.transactionList[0];
-            if (tx.bodyBytes && tx.bodyBytes.length > 0) {
-              const txBody = proto.TransactionBody.decode(tx.bodyBytes);
-              const typeResult = this.detectTransactionTypeFromBody(txBody);
-              finalType = typeResult.type;
-              finalHumanReadableType = typeResult.humanReadableType;
-              protoParsingResult = this.parseTransactionBodyDetails(
-                txBody,
-                finalType
-              );
-              if (protoParsingResult.tokenCreation) {
-                parsedTokenCreation = protoParsingResult.tokenCreation;
-              }
-            } else if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
-              const signedTx = proto.SignedTransaction.decode(
-                tx.signedTransactionBytes
-              );
-              if (signedTx.bodyBytes) {
-                const txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
-                const typeResult = this.detectTransactionTypeFromBody(txBody);
-                finalType = typeResult.type;
-                finalHumanReadableType = typeResult.humanReadableType;
-                protoParsingResult = this.parseTransactionBodyDetails(
-                  txBody,
-                  finalType
-                );
-                if (protoParsingResult.tokenCreation) {
-                  parsedTokenCreation = protoParsingResult.tokenCreation;
-                }
-              }
-            }
-          }
-        } catch (protoError) {
-        }
-      }
-      if (finalType === "UNKNOWN" && primaryResult.type) {
-        finalType = primaryResult.type;
-        finalHumanReadableType = primaryResult.humanReadableType || finalHumanReadableType;
-      }
-      const result = {
-        type: finalType,
-        humanReadableType: finalHumanReadableType,
-        transfers: [],
-        tokenTransfers: [],
-        ...metadata,
-        ...primaryResult,
-        raw: actualOptions.includeRaw ? transaction._transactionBody || {} : void 0
-      };
-      this.mergeProtoParsingResults(
-        result,
-        protoParsingResult,
-        htsResult,
-        transaction,
-        originalBytes
-      );
-      result.transfers = cryptoResult.transfers || result.transfers || [];
-      result.tokenTransfers = cryptoResult.tokenTransfers || result.tokenTransfers || [];
-      return result;
-    } catch (error) {
-      return {
-        type: "UNKNOWN",
-        humanReadableType: "Unknown Transaction",
-        transfers: [],
-        tokenTransfers: [],
-        raw: actualOptions.includeRaw ? {} : void 0,
-        details: {
-          error: `Failed to parse Transaction object: ${error instanceof Error ? error.message : String(error)}`
-        }
-      };
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return null;
     }
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
   }
-  /**
-   * Parse a base64 encoded transaction body using registry pattern
-   * @param transactionBodyBase64 - The base64 encoded transaction body
-   * @returns The parsed transaction
-   */
-  static parseTransactionBody(transactionBodyBase64) {
-    try {
-      const buffer = ethers.decodeBase64(transactionBodyBase64);
-      const txBody = proto.SchedulableTransactionBody.decode(buffer);
-      const transactionType = this.getTransactionType(txBody);
-      const result = {
-        type: transactionType,
-        humanReadableType: this.getHumanReadableType(transactionType),
-        transfers: [],
-        tokenTransfers: [],
-        raw: txBody
-      };
-      if (txBody.memo) {
-        result.memo = txBody.memo;
-      }
-      if (txBody.transactionFee) {
-        const hbarAmount = Hbar.fromTinybars(
-          Long.fromValue(txBody.transactionFee)
-        );
-        result.transactionFee = hbarAmount.toString(HbarUnit.Hbar);
-      }
-      this.applySchedulableTransactionParsing(txBody, result);
-      return result;
-    } catch (error) {
-      return {
-        type: "UNKNOWN",
-        humanReadableType: "Unknown Transaction",
-        transfers: [],
-        tokenTransfers: [],
-        raw: void 0,
-        details: {
-          error: `Failed to parse transaction body: ${error instanceof Error ? error.message : String(error)}`
-        }
-      };
-    }
+  return null;
+};
+const parseChainIdFromNetworkKey = (networkKey) => {
+  if (typeof networkKey !== "string") {
+    return null;
   }
-  /**
-   * Detect transaction type and human-readable type from transaction body protobuf
-   * Uses registry pattern to eliminate massive if-else chain
-   */
-  static detectTransactionTypeFromBody(txBody) {
-    return getTransactionTypeFromBody(txBody);
+  const trimmed = networkKey.trim();
+  if (!trimmed) {
+    return null;
   }
-  /**
-   * Parse details from a complete schedule response
-   * @param scheduleResponse - The schedule response to parse
-   * @returns The parsed transaction
-   */
-  static parseScheduleResponse(scheduleResponse) {
-    if (!scheduleResponse.transaction_body) {
-      return {
-        type: "UNKNOWN",
-        humanReadableType: "Unknown Transaction",
-        transfers: [],
-        tokenTransfers: [],
-        raw: void 0,
-        details: {
-          error: "Schedule response missing transaction_body"
-        }
-      };
-    }
-    const parsed = this.parseTransactionBody(scheduleResponse.transaction_body);
-    if (scheduleResponse.memo) {
-      parsed.memo = scheduleResponse.memo;
-    }
-    return parsed;
+  const match = /^eip155:(\d+)(?::|$)/i.exec(trimmed);
+  if (!match) {
+    return null;
   }
-  /**
-   * Determine the transaction type using registry pattern
-   * @param txBody - The transaction body to determine the type of
-   * @returns The type of the transaction
-   */
-  static getTransactionType(txBody) {
-    return getTransactionTypeFromBody(txBody).type;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+const parseIdParts = (value) => {
+  if (typeof value !== "string") {
+    return null;
   }
-  /**
-   * Convert technical transaction type to human-readable format using registry pattern
-   * @param type - The technical transaction type
-   * @returns The human-readable transaction type
-   */
-  static getHumanReadableType(type) {
-    return getHumanReadableTransactionType(type);
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
   }
-  /**
-   * Get a human-readable summary of the transaction
-   * @param parsedTx - The parsed transaction
-   * @returns The human-readable summary of the transaction
-   */
-  static getTransactionSummary(parsedTx) {
-    return resolveTransactionSummary(parsedTx);
+  const separator = trimmed.indexOf(":");
+  if (separator <= 0 || separator !== trimmed.lastIndexOf(":")) {
+    return null;
   }
-  /**
-   * Validate transaction bytes format and encoding
-   * Enhanced validation with better format detection
-   */
-  static validateTransactionBytes(transactionBytes) {
-    if (!transactionBytes || typeof transactionBytes !== "string") {
+  const chainId = Number.parseInt(trimmed.slice(0, separator), 10);
+  const agentId = trimmed.slice(separator + 1);
+  if (!Number.isFinite(chainId) || chainId <= 0 || !agentId) {
+    return null;
+  }
+  return { chainId, agentId };
+};
+function parseErc8004NativeId(subject) {
+  const metadata = subject.metadata ?? {};
+  const idParts = parseIdParts(readString(metadata, "originalId")) ?? parseIdParts(readString(metadata, "nativeId")) ?? parseIdParts(readString(metadata, "uid"));
+  const agentId = parseNonNegativeInt(metadata["agentId"]) ?? (idParts ? parseNonNegativeInt(idParts.agentId) : null);
+  const chainId = parsePositiveInt(metadata["chainId"]) ?? parseChainIdFromNetworkKey(metadata["networkKey"]) ?? idParts?.chainId ?? null;
+  if (agentId === null || chainId === null) {
+    return null;
+  }
+  return { chainId, agentId: String(agentId) };
+}
+function createHttpErc8004FeedbackSource(options) {
+  return {
+    async getFeedbackSummary(subject, context) {
+      const nativeId = parseErc8004NativeId(subject);
+      if (!nativeId) {
+        return null;
+      }
+      const url = typeof options.endpoint === "function" ? options.endpoint(subject) : options.endpoint.replace("{nativeId}", `${nativeId.chainId}:${nativeId.agentId}`).replace("{chainId}", String(nativeId.chainId)).replace("{agentId}", nativeId.agentId);
+      if (!url) {
+        return null;
+      }
+      const data = await requestJson(url, {
+        fetch: context.fetch,
+        timeoutMs: context.timeoutMs,
+        signal: context.signal
+      });
+      const summary = data.summary ?? data;
+      const averageScore = typeof summary.averageScore === "number" ? summary.averageScore : null;
+      const totalFeedbacks = typeof summary.totalFeedbacks === "number" ? summary.totalFeedbacks : typeof data.count === "number" ? data.count : null;
+      if (averageScore === null && totalFeedbacks === null) {
+        return null;
+      }
       return {
-        isValid: false,
-        error: "Transaction bytes must be a non-empty string"
+        averageScore: averageScore ?? 0,
+        totalFeedbacks: totalFeedbacks ?? 0,
+        registry: summary.registry ?? "erc-8004",
+        network: summary.network ?? String(nativeId.chainId),
+        updatedAt: summary.updatedAt
       };
     }
-    const format = this.detectTransactionFormat(transactionBytes);
-    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
-    const hexRegex = /^0x[0-9a-fA-F]+$/;
-    let isValid = false;
-    let error;
-    if (format === "hex") {
-      isValid = hexRegex.test(transactionBytes) && transactionBytes.length > 2;
-      if (!isValid) {
-        error = "Invalid hex format";
-      }
-    } else {
-      isValid = base64Regex.test(transactionBytes) && transactionBytes.length > 0;
-      if (!isValid) {
-        error = "Invalid base64 format";
-      }
-    }
-    return {
-      isValid,
-      format,
-      error,
-      length: transactionBytes.length
-    };
-  }
-  /**
-   * Detects the format of transaction bytes
-   * @param transactionBytes - The transaction bytes to analyze
-   * @returns The detected format ('base64' or 'hex')
-   */
-  static detectTransactionFormat(transactionBytes) {
-    return transactionBytes.startsWith("0x") ? "hex" : "base64";
-  }
-  /**
-   * Decodes transaction bytes from string to Uint8Array
-   * @param transactionBytes - The transaction bytes string (base64 or hex)
-   * @returns Decoded Uint8Array
-   * @throws TransactionParsingError if decoding fails
-   */
-  static decodeTransactionBytes(transactionBytes) {
-    try {
-      const format = this.detectTransactionFormat(transactionBytes);
-      if (format === "hex") {
-        const hexString = transactionBytes.slice(2);
-        return new Uint8Array(Buffer.from(hexString, "hex"));
-      } else {
-        return new Uint8Array(Buffer.from(transactionBytes, "base64"));
+  };
+}
+const ERC8004_REPUTATION_ABI = [
+  "function getClients(uint256 agentId) view returns (address[])",
+  "function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)"
+];
+function createOnchainErc8004FeedbackSource(options) {
+  const scoreScale = options.scoreScale ?? "auto";
+  return {
+    async getFeedbackSummary(subject) {
+      const nativeId = parseErc8004NativeId(subject);
+      if (!nativeId) {
+        return null;
+      }
+      const registry = options.registries[nativeId.chainId];
+      if (!registry) {
+        return null;
+      }
+      const contract = options.contractFor(nativeId.chainId, registry);
+      const agentId = BigInt(nativeId.agentId);
+      const clients = await contract.getClients(agentId);
+      if (clients.length === 0) {
+        return {
+          averageScore: 0,
+          totalFeedbacks: 0,
+          network: String(nativeId.chainId)
+        };
       }
-    } catch (error) {
-      throw new TransactionParsingError(
-        "Failed to decode transaction bytes",
-        "DECODE_ERROR",
-        error instanceof Error ? error : void 0,
-        transactionBytes
+      const [count, summaryValue, decimals] = await contract.getSummary(
+        agentId,
+        [...clients],
+        options.tag1 ?? "",
+        options.tag2 ?? ""
       );
-    }
-  }
-  /**
-   * Check if transaction bytes represent a valid Hedera transaction
-   */
-  static async isValidHederaTransaction(transactionBytes) {
-    try {
-      if (!this.validateTransactionBytes(transactionBytes).isValid) {
-        return false;
-      }
-      const bytes = this.decodeTransactionBytes(transactionBytes);
-      Transaction.fromBytes(bytes);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Legacy alias for decodeTransactionBytes - keeping for backward compatibility
-   */
-  static decodeBytesLegacy(transactionBytes) {
-    return this.decodeTransactionBytes(transactionBytes);
-  }
-  /**
-   * Parse transaction bytes into structured data using thin orchestration
-   * Delegates to specialized parsers for clean separation of concerns
-   */
-  static async parseTransaction(transactionBytes, options = {}) {
-    try {
-      const bytes = this.decodeTransactionBytes(transactionBytes);
-      const transaction = Transaction.fromBytes(bytes);
-      const metadata = this.extractTransactionMetadataEnhanced(transaction);
-      const parserResults = this.runAllParsers(transaction);
-      const primaryResult = parserResults.find(
-        (result2) => result2.type && result2.type !== "UNKNOWN"
-      ) || {};
-      const protoParsingResult = this.parseFromProtobuf(bytes);
-      const finalType = protoParsingResult.type || primaryResult.type || "UNKNOWN";
-      const finalHumanReadableType = protoParsingResult.humanReadableType || primaryResult.humanReadableType || "Unknown Transaction";
-      const result = {
-        type: finalType,
-        humanReadableType: finalHumanReadableType,
-        transfers: [],
-        tokenTransfers: [],
-        details: { ...metadata },
-        memo: typeof metadata.memo === "string" ? metadata.memo : void 0,
-        transactionId: typeof metadata.transactionId === "string" ? metadata.transactionId : void 0,
-        nodeAccountIds: Array.isArray(metadata.nodeAccountIds) ? metadata.nodeAccountIds : [],
-        maxTransactionFee: typeof metadata.maxTransactionFee === "string" ? metadata.maxTransactionFee : void 0,
-        validStart: typeof metadata.validStart === "string" ? metadata.validStart : void 0,
-        validDuration: typeof metadata.validDuration === "string" ? metadata.validDuration : void 0,
-        raw: options.includeRaw ? {} : void 0
+      const raw = Number(summaryValue) / 10 ** Number(decimals);
+      const averageScore = scoreScale === "ratio5" ? raw * 20 : scoreScale === "percent" ? raw : raw <= 5 ? raw * 20 : raw;
+      return {
+        averageScore: Math.min(100, Math.max(0, averageScore)),
+        totalFeedbacks: Number(count),
+        network: String(nativeId.chainId)
       };
-      this.mergeAllResults(
-        result,
-        protoParsingResult,
-        primaryResult,
-        parserResults
-      );
-      return result;
-    } catch (error) {
-      throw new TransactionParsingError(
-        "Failed to parse as regular transaction",
-        "REGULAR_PARSING_FAILED",
-        error instanceof Error ? error : void 0,
-        transactionBytes
-      );
     }
-  }
-  /**
-   * Parse scheduled transaction body
-   */
-  static parseScheduledTransaction(transactionBytes, options = {}) {
-    try {
-      const parsedTx = this.parseTransactionBody(transactionBytes);
-      const validation = this.validateTransactionBytes(transactionBytes);
-      const enhancedResult = {
-        ...parsedTx,
-        details: {
-          ...parsedTx.details || {},
-          parseMethod: "scheduled",
-          validation,
-          parseAttempts: parsedTx.details?.parseAttempts || 1
-        },
-        formatDetection: {
-          originalFormat: validation.format || "base64",
-          wasConverted: false,
-          length: transactionBytes.length
+  };
+}
+const DEFAULT_INCLUDED_REGISTRIES = ["erc-8004"];
+function statusFromError(error) {
+  return isTimeoutError(error) ? "timeout" : "error";
+}
+function createErc8004SignalAdapter(options) {
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const nativeId = parseErc8004NativeId(subject);
+    if (!nativeId) {
+      return [{ signalId: "erc8004.feedback", status: "missing" }];
+    }
+    let lastError = null;
+    for (const source of options.sources) {
+      try {
+        const summary = await source.getFeedbackSummary(subject, context);
+        if (!summary) {
+          continue;
         }
-      };
-      return enhancedResult;
-    } catch (error) {
-      throw new TransactionParsingError(
-        "Failed to parse as scheduled transaction",
-        "SCHEDULED_PARSING_FAILED",
-        error instanceof Error ? error : void 0,
-        transactionBytes
-      );
-    }
-  }
-  /**
-   * Extract metadata from Transaction object (legacy method - keeping for backward compatibility)
-   */
-  static extractTransactionMetadata(transaction) {
-    return {
-      transactionId: transaction.transactionId?.toString(),
-      nodeAccountIds: transaction.nodeAccountIds?.map((id) => id.toString()) || [],
-      maxTransactionFee: transaction.maxTransactionFee?.toTinybars().toString() || "0",
-      memo: transaction._transactionMemo || void 0,
-      transfers: [],
-      tokenTransfers: []
-    };
-  }
-  /**
-   * Extract enhanced metadata from Transaction object
-   */
-  static extractTransactionMetadataEnhanced(transaction) {
-    return {
-      transactionId: transaction.transactionId?.toString(),
-      nodeAccountIds: transaction.nodeAccountIds?.map((id) => id.toString()) || [],
-      maxTransactionFee: transaction.maxTransactionFee?.toTinybars().toString() || "0",
-      memo: transaction._transactionMemo || void 0,
-      validStart: transaction._transactionValidStart?.toString(),
-      validDuration: transaction._transactionValidDuration?.toString()
-    };
-  }
-  /**
-   * Run all available parsers on a transaction
-   */
-  static runAllParsers(transaction) {
-    return [
-      HTSParser.parseFromTransactionObject(transaction),
-      CryptoParser.parseFromTransactionObject(transaction),
-      HCSParser.parseFromTransactionObject(transaction),
-      FileParser.parseFromTransactionObject(transaction),
-      SCSParser.parseFromTransactionObject(transaction),
-      ScheduleParser.parseFromTransactionObject(transaction),
-      UtilParser.parseFromTransactionObject(transaction)
-    ];
-  }
-  /**
-   * Parse transaction from protobuf bytes
-   */
-  static parseFromProtobuf(bytes) {
-    const result = {};
-    try {
-      const decoded = proto.TransactionList.decode(bytes);
-      if (decoded.transactionList && decoded.transactionList.length > 0) {
-        const tx = decoded.transactionList[0];
-        let txBody = null;
-        if (tx.bodyBytes && tx.bodyBytes.length > 0) {
-          txBody = proto.TransactionBody.decode(tx.bodyBytes);
-        } else if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
-          const signedTx = proto.SignedTransaction.decode(
-            tx.signedTransactionBytes
-          );
-          if (signedTx.bodyBytes) {
-            txBody = proto.TransactionBody.decode(signedTx.bodyBytes);
+        const averageScore = Math.min(
+          100,
+          Math.max(0, Number(summary.averageScore) || 0)
+        );
+        const totalFeedbacks = Math.max(
+          0,
+          Math.floor(Number(summary.totalFeedbacks) || 0)
+        );
+        const record = {
+          averageScore,
+          totalFeedbacks,
+          registry: summary.registry ?? subject.registry ?? "erc-8004",
+          network: summary.network ?? String(nativeId.chainId),
+          updatedAt: summary.updatedAt ?? now
+        };
+        return [
+          {
+            signalId: "erc8004.feedback",
+            status: "ok",
+            value: averageScore,
+            fields: [{ scope: "erc8004FeedbackSummary", values: record }],
+            provenance: {
+              source: "erc8004",
+              subjectId: `${nativeId.chainId}:${nativeId.agentId}`,
+              fetchedAt: now
+            }
           }
-        }
-        if (txBody) {
-          const typeResult = this.detectTransactionTypeFromBody(txBody);
-          result.type = typeResult.type;
-          result.humanReadableType = typeResult.humanReadableType;
-          const details = this.parseTransactionBodyDetails(
-            txBody,
-            typeResult.type
-          );
-          Object.assign(result, details);
-        }
+        ];
+      } catch (error) {
+        lastError = error;
+        continue;
       }
-    } catch (error) {
     }
-    return result;
-  }
-  /**
-   * Intelligently merge all parsing results
-   */
-  static mergeAllResults(result, protoResult, primaryResult, parserResults) {
-    const cryptoResult = parserResults.find((r) => r.transfers || r.tokenTransfers) || {};
-    result.transfers = cryptoResult.transfers || result.transfers || [];
-    result.tokenTransfers = cryptoResult.tokenTransfers || result.tokenTransfers || [];
-    Object.keys(protoResult).forEach((key) => {
-      if (protoResult[key] !== void 0 && key !== "type" && key !== "humanReadableType") {
-        result[key] = protoResult[key];
-      }
-    });
-    Object.keys(primaryResult).forEach((key) => {
-      if (primaryResult[key] !== void 0 && !(key in result) && key !== "type" && key !== "humanReadableType") {
-        result[key] = primaryResult[key];
+    if (lastError) {
+      if (lastError instanceof Hcs25CollectorHttpError && lastError.status === 404) {
+        return [{ signalId: "erc8004.feedback", status: "missing" }];
       }
-    });
-  }
-  /**
-   * Apply schedulable transaction parsing using registry pattern
-   * Eliminates conditional logic in parseTransactionBody
-   */
-  static applySchedulableTransactionParsing(txBody, result) {
-    if (txBody.cryptoTransfer) {
-      CryptoParser.parseCryptoTransfers(txBody.cryptoTransfer, result);
-    }
-    if (txBody.cryptoDelete) {
-      result.cryptoDelete = CryptoParser.parseCryptoDelete(txBody.cryptoDelete);
-    }
-    if (txBody.cryptoCreateAccount) {
-      result.cryptoCreateAccount = CryptoParser.parseCryptoCreateAccount(
-        txBody.cryptoCreateAccount
-      );
-    }
-    if (txBody.cryptoUpdateAccount) {
-      result.cryptoUpdateAccount = CryptoParser.parseCryptoUpdateAccount(
-        txBody.cryptoUpdateAccount
-      );
-    }
-    if (txBody.cryptoApproveAllowance) {
-      result.cryptoApproveAllowance = CryptoParser.parseCryptoApproveAllowance(
-        txBody.cryptoApproveAllowance
-      );
-    }
-    if (txBody.cryptoDeleteAllowance) {
-      result.cryptoDeleteAllowance = CryptoParser.parseCryptoDeleteAllowance(
-        txBody.cryptoDeleteAllowance
-      );
-    }
-    if (txBody.contractCall) {
-      result.contractCall = SCSParser.parseContractCall(txBody.contractCall);
-    }
-    if (txBody.contractCreateInstance) {
-      result.contractCreate = SCSParser.parseContractCreate(
-        txBody.contractCreateInstance
-      );
-    }
-    if (txBody.contractUpdateInstance) {
-      result.contractUpdate = SCSParser.parseContractUpdate(
-        txBody.contractUpdateInstance
-      );
-    }
-    if (txBody.contractDeleteInstance) {
-      result.contractDelete = SCSParser.parseContractDelete(
-        txBody.contractDeleteInstance
-      );
-    }
-    if (txBody.tokenCreation) {
-      result.tokenCreation = HTSParser.parseTokenCreate(txBody.tokenCreation);
-    }
-    if (txBody.tokenMint) {
-      result.tokenMint = HTSParser.parseTokenMint(txBody.tokenMint);
-    }
-    if (txBody.tokenBurn) {
-      result.tokenBurn = HTSParser.parseTokenBurn(txBody.tokenBurn);
-    }
-    if (txBody.tokenUpdate) {
-      result.tokenUpdate = HTSParser.parseTokenUpdate(txBody.tokenUpdate);
-    }
-    if (txBody.tokenFeeScheduleUpdate) {
-      result.tokenFeeScheduleUpdate = HTSParser.parseTokenFeeScheduleUpdate(
-        txBody.tokenFeeScheduleUpdate
-      );
-    }
-    if (txBody.tokenFreeze) {
-      result.tokenFreeze = HTSParser.parseTokenFreeze(txBody.tokenFreeze);
-    }
-    if (txBody.tokenUnfreeze) {
-      result.tokenUnfreeze = HTSParser.parseTokenUnfreeze(txBody.tokenUnfreeze);
-    }
-    if (txBody.tokenGrantKyc) {
-      result.tokenGrantKyc = HTSParser.parseTokenGrantKyc(txBody.tokenGrantKyc);
-    }
-    if (txBody.tokenRevokeKyc) {
-      result.tokenRevokeKyc = HTSParser.parseTokenRevokeKyc(
-        txBody.tokenRevokeKyc
-      );
-    }
-    if (txBody.tokenPause) {
-      result.tokenPause = HTSParser.parseTokenPause(txBody.tokenPause);
-    }
-    if (txBody.tokenUnpause) {
-      result.tokenUnpause = HTSParser.parseTokenUnpause(txBody.tokenUnpause);
-    }
-    if (txBody.tokenWipe) {
-      result.tokenWipeAccount = HTSParser.parseTokenWipeAccount(
-        txBody.tokenWipe
-      );
-    }
-    if (txBody.tokenDeletion) {
-      result.tokenDelete = HTSParser.parseTokenDelete(txBody.tokenDeletion);
-    }
-    if (txBody.tokenAssociate) {
-      result.tokenAssociate = HTSParser.parseTokenAssociate(
-        txBody.tokenAssociate
-      );
-    }
-    if (txBody.tokenDissociate) {
-      result.tokenDissociate = HTSParser.parseTokenDissociate(
-        txBody.tokenDissociate
-      );
-    }
-    if (txBody.tokenAirdrop) {
-      result.tokenAirdrop = HTSParser.parseTokenAirdropFromProto(
-        txBody.tokenAirdrop
-      );
-    }
-    if (txBody.consensusCreateTopic) {
-      result.consensusCreateTopic = HCSParser.parseConsensusCreateTopic(
-        txBody.consensusCreateTopic
-      );
-    }
-    if (txBody.consensusSubmitMessage) {
-      result.consensusSubmitMessage = HCSParser.parseConsensusSubmitMessage(
-        txBody.consensusSubmitMessage
-      );
-    }
-    if (txBody.consensusUpdateTopic) {
-      result.consensusUpdateTopic = HCSParser.parseConsensusUpdateTopic(
-        txBody.consensusUpdateTopic
-      );
-    }
-    if (txBody.consensusDeleteTopic) {
-      result.consensusDeleteTopic = HCSParser.parseConsensusDeleteTopic(
-        txBody.consensusDeleteTopic
-      );
-    }
-    if (txBody.fileCreate) {
-      result.fileCreate = FileParser.parseFileCreate(txBody.fileCreate);
-    }
-    if (txBody.fileAppend) {
-      result.fileAppend = FileParser.parseFileAppend(txBody.fileAppend);
-    }
-    if (txBody.fileUpdate) {
-      result.fileUpdate = FileParser.parseFileUpdate(txBody.fileUpdate);
-    }
-    if (txBody.fileDelete) {
-      result.fileDelete = FileParser.parseFileDelete(txBody.fileDelete);
-    }
-    if (txBody.utilPrng) {
-      result.utilPrng = UtilParser.parseUtilPrng(txBody.utilPrng);
-    }
-  }
-  /**
-   * Parse transaction body details for all supported transaction types
-   * Uses a scalable registry pattern instead of if-else chains
-   */
-  static parseTransactionBodyDetails(txBody, transactionType) {
-    const result = {};
-    const parserConfig = transactionParserRegistry[transactionType];
-    if (parserConfig) {
-      const bodyData = txBody[parserConfig.bodyField];
-      if (bodyData) {
-        const parserResult = parserConfig.parser(bodyData);
-        if (parserConfig.spreadResult) {
-          Object.assign(result, parserResult);
-        } else {
-          result[parserConfig.resultField] = parserResult;
+      return [
+        {
+          signalId: "erc8004.feedback",
+          status: statusFromError(lastError)
         }
-      }
-    }
-    return result;
-  }
-  /**
-   * Merge protobuf parsing results with parser results using registry pattern
-   * Eliminates transactionFields array and forEach logic
-   */
-  static mergeProtoParsingResults(result, protoResult, htsResult, transaction, originalBytes) {
-    const fieldsToMerge = Object.values(transactionParserRegistry).map(
-      (config) => config.resultField
-    );
-    for (const field of fieldsToMerge) {
-      const protoValue = protoResult[field];
-      const htsValue = htsResult[field];
-      if (protoValue !== void 0) {
-        result[field] = protoValue;
-      } else if (htsValue !== void 0) {
-        result[field] = htsValue;
-      } else {
-        this.handleSpecialFieldExtraction(result, field, transaction);
-      }
-    }
-  }
-  /**
-   * Handle special field extraction cases using registry pattern
-   */
-  static handleSpecialFieldExtraction(result, field, transaction) {
-    if (field === "tokenCreation" && result.type === "TOKENCREATE") {
-      const extracted = HTSParser.extractTokenCreationFromTransaction(transaction);
-      if (extracted) {
-        result[field] = extracted;
-      }
-    } else if (field === "tokenAirdrop" && result.type === "TOKENAIRDROP") {
-      const extracted = HTSParser.extractTokenAirdropFromTransaction(transaction);
-      if (extracted) {
-        result[field] = extracted;
-      }
+      ];
     }
-  }
-  /**
-   * Create fallback result when all parsing methods fail
-   */
-  static createFallbackResult(transactionBytes, primaryError, secondaryError) {
-    const validation = this.validateTransactionBytes(transactionBytes);
-    return {
-      type: "UNKNOWN",
-      humanReadableType: "Unknown Transaction",
-      transfers: [],
-      tokenTransfers: [],
-      details: {
-        rawBytes: transactionBytes.length > 100 ? transactionBytes.substring(0, 100) + "..." : transactionBytes,
-        primaryError: primaryError?.message,
-        secondaryError: secondaryError?.message,
-        parseAttempts: secondaryError ? 2 : 1,
-        validation
-      },
-      formatDetection: {
-        originalFormat: validation.format || "base64",
-        wasConverted: false,
-        length: transactionBytes.length
-      },
-      raw: {}
-    };
-  }
+    return [{ signalId: "erc8004.feedback", status: "missing" }];
+  };
+  return {
+    id: "erc8004-feedback",
+    produces: ["erc8004.feedback"],
+    timeoutMs: options.timeoutMs,
+    includeRegistries: options.includeRegistries ?? DEFAULT_INCLUDED_REGISTRIES,
+    excludeRegistries: options.excludeRegistries,
+    appliesTo: options.appliesTo,
+    collect
+  };
 }
 export {
-  TransactionParser,
-  TransactionParsingError
+  ERC8004_REPUTATION_ABI,
+  createErc8004SignalAdapter,
+  createHttpErc8004FeedbackSource,
+  createOnchainErc8004FeedbackSource,
+  parseErc8004NativeId
 };
 //# sourceMappingURL=standards-sdk.es133.js.map