@hashgraphonline/standards-sdk 0.1.183 → 0.1.185

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

@@ -1,520 +1,334 @@
-import { createSessionResponseSchema, chatSessionResumeResponseSchema, chatReadinessResponseSchema, chatHistoryCompactionResponseSchema, sessionEncryptionStatusResponseSchema, encryptionHandshakeResponseSchema, sendMessageResponseSchema, chatSessionEndResponseSchema } from "./standards-sdk.es161.js";
-import { serialiseAuthConfig, toJsonObject } from "./standards-sdk.es186.js";
-import { EncryptionUnavailableError } from "./standards-sdk.es178.js";
-function createChatApi(client, encryptedManager) {
-  return {
-    start: (options) => client.startChat(options),
-    readiness: (payload) => client.checkChatReadiness(payload),
-    createSession: (payload) => client.createSession(payload),
-    resumeSession: (sessionId) => client.resumeSession(sessionId),
-    sendMessage: (payload) => client.sendMessage(payload),
-    retryMessage: (messageId, payload) => client.retryMessage(messageId, payload),
-    cancelSession: (sessionId) => client.cancelSession(sessionId),
-    endSession: (sessionId) => client.endSession(sessionId),
-    getHistory: (sessionId, options) => client.fetchHistorySnapshot(sessionId, options),
-    compactHistory: (payload) => client.compactHistory(payload),
-    getEncryptionStatus: (sessionId) => client.fetchEncryptionStatus(sessionId),
-    submitEncryptionHandshake: (sessionId, payload) => client.postEncryptionHandshake(sessionId, payload),
-    startConversation: (options) => client.startConversation(options),
-    acceptConversation: (options) => client.acceptConversation(options),
-    createEncryptedSession: (options) => encryptedManager.startSession(options),
-    acceptEncryptedSession: (options) => encryptedManager.acceptSession(options)
-  };
-}
-async function checkChatReadiness(client, payload) {
-  const body = {};
-  const uaid = "uaid" in payload ? payload.uaid?.trim() : void 0;
-  const agentUrl = "agentUrl" in payload ? payload.agentUrl?.trim() : void 0;
-  if (!uaid && !agentUrl) {
-    throw new Error("uaid or agentUrl is required to check chat readiness");
-  }
-  if (uaid) {
-    body.uaid = uaid;
-  }
-  if (agentUrl) {
-    body.agentUrl = agentUrl;
-  }
-  if (payload.forceRefresh !== void 0) {
-    body.forceRefresh = payload.forceRefresh;
-  }
-  const raw = await client.requestJson("/chat/readiness", {
-    method: "POST",
-    body,
-    headers: { "content-type": "application/json" }
-  });
-  return client.parseWithSchema(
-    raw,
-    chatReadinessResponseSchema,
-    "chat readiness response"
-  );
-}
-async function createSession(client, payload, allowHistoryAutoTopUp = true) {
-  const body = {};
-  if ("uaid" in payload && payload.uaid) {
-    body.uaid = payload.uaid;
-  }
-  if ("agentUrl" in payload && payload.agentUrl) {
-    body.agentUrl = payload.agentUrl;
-  }
-  if (payload.auth) {
-    body.auth = serialiseAuthConfig(payload.auth);
-  }
-  if (payload.historyTtlSeconds !== void 0) {
-    body.historyTtlSeconds = payload.historyTtlSeconds;
-  }
-  if (payload.encryptionRequested !== void 0) {
-    body.encryptionRequested = payload.encryptionRequested;
-  }
-  if (payload.senderUaid) {
-    body.senderUaid = payload.senderUaid;
-  }
-  if (payload.visibility) {
-    body.visibility = payload.visibility;
-  }
-  if (payload.idempotencyKey) {
-    body.idempotencyKey = payload.idempotencyKey;
-  }
-  try {
-    const raw = await client.requestJson("/chat/session", {
-      method: "POST",
-      body,
-      headers: { "content-type": "application/json" }
-    });
-    return client.parseWithSchema(
-      raw,
-      createSessionResponseSchema,
-      "chat session response"
-    );
-  } catch (error) {
-    const maybeError = error instanceof Error ? error : null;
-    if (allowHistoryAutoTopUp && client.shouldAutoTopUpHistory(payload, maybeError)) {
-      await client.executeHistoryAutoTopUp("chat.session");
-      return createSession(client, payload, false);
+import { proto } from "@hashgraph/proto";
+import { Long, FileId, ContractId } from "@hashgraph/sdk";
+import { hasTransactionType } from "./standards-sdk.es178.js";
+class UtilParser {
+  /**
+   * Parse Utility/System Service transaction using unified dual-branch approach
+   * This handles both regular transactions and signed transaction variants
+   */
+  static parseUtilTransaction(transaction, originalBytes) {
+    try {
+      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];
+            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);
+              }
+            }
+            if (txBody) {
+              const protoResult = this.parseFromProtobufTxBody(txBody);
+              if (protoResult.type && protoResult.type !== "UNKNOWN") {
+                return protoResult;
+              }
+            }
+          }
+        } catch (protoError) {
+        }
+      }
+      return this.parseFromTransactionInternals(transaction);
+    } catch (error) {
+      return {
+        type: "UNKNOWN",
+        humanReadableType: "Unknown Utility Transaction"
+      };
     }
-    throw error;
-  }
-}
-async function resumeSession(client, sessionId) {
-  const normalized = sessionId.trim();
-  if (!normalized) {
-    throw new Error("sessionId is required to resume a chat session");
-  }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(normalized)}/resume`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    chatSessionResumeResponseSchema,
-    "chat session resume response"
-  );
-}
-async function startChat(client, encryptedManager, options) {
-  if ("uaid" in options && options.uaid) {
-    return startConversation(client, encryptedManager, {
-      uaid: options.uaid,
-      senderUaid: options.senderUaid,
-      historyTtlSeconds: options.historyTtlSeconds,
-      auth: options.auth,
-      encryption: options.encryption,
-      onSessionCreated: options.onSessionCreated
-    });
   }
-  if ("agentUrl" in options && options.agentUrl) {
-    const session = await createSession(client, {
-      agentUrl: options.agentUrl,
-      auth: options.auth,
-      historyTtlSeconds: options.historyTtlSeconds,
-      senderUaid: options.senderUaid
-    });
-    options.onSessionCreated?.(session.sessionId);
-    return createPlaintextConversationHandle(
-      client,
-      session.sessionId,
-      session.encryption ?? null,
-      options.auth,
-      { agentUrl: options.agentUrl, uaid: options.uaid }
-    );
-  }
-  throw new Error("startChat requires either uaid or agentUrl");
-}
-async function startConversation(client, encryptedManager, options) {
-  const preference = options.encryption?.preference ?? "preferred";
-  const requestEncryption = preference !== "disabled";
-  if (!requestEncryption) {
-    const session = await createSession(client, {
-      uaid: options.uaid,
-      auth: options.auth,
-      historyTtlSeconds: options.historyTtlSeconds,
-      senderUaid: options.senderUaid,
-      encryptionRequested: false
-    });
-    options.onSessionCreated?.(session.sessionId);
-    return createPlaintextConversationHandle(
-      client,
-      session.sessionId,
-      session.encryption ?? null,
-      options.auth,
-      { uaid: options.uaid }
-    );
-  }
-  try {
-    const handle = await encryptedManager.startSession({
-      uaid: options.uaid,
-      senderUaid: options.senderUaid,
-      historyTtlSeconds: options.historyTtlSeconds,
-      handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
-      pollIntervalMs: options.encryption?.pollIntervalMs,
-      onSessionCreated: (sessionId) => {
-        options.onSessionCreated?.(sessionId);
-      },
-      auth: options.auth
-    });
-    return handle;
-  } catch (error) {
-    if (error instanceof EncryptionUnavailableError) {
-      if (preference === "required") {
-        throw error;
+  /**
+   * Parse utility transaction from protobuf TransactionBody
+   * Handles all utility operations from decoded protobuf data
+   */
+  static parseFromProtobufTxBody(txBody) {
+    if (txBody.utilPrng) {
+      const utilPrng = this.parseUtilPrng(txBody.utilPrng);
+      if (utilPrng) {
+        return {
+          type: "PRNG",
+          humanReadableType: "Pseudo Random Number",
+          utilPrng
+        };
       }
-      return createPlaintextConversationHandle(
-        client,
-        error.sessionId,
-        error.summary ?? null,
-        options.auth,
-        { uaid: options.uaid }
-      );
     }
-    throw error;
-  }
-}
-async function acceptConversation(client, encryptedManager, options) {
-  const preference = options.encryption?.preference ?? "preferred";
-  if (preference === "disabled") {
-    return createPlaintextConversationHandle(client, options.sessionId, null);
-  }
-  try {
-    const handle = await encryptedManager.acceptSession({
-      sessionId: options.sessionId,
-      responderUaid: options.responderUaid,
-      handshakeTimeoutMs: options.encryption?.handshakeTimeoutMs,
-      pollIntervalMs: options.encryption?.pollIntervalMs
-    });
-    return handle;
-  } catch (error) {
-    if (error instanceof EncryptionUnavailableError && preference !== "required") {
-      return createPlaintextConversationHandle(
-        client,
-        options.sessionId,
-        null,
-        void 0,
-        { uaid: options.responderUaid }
+    if (txBody.freeze) {
+      const networkFreeze = this.parseNetworkFreezeFromProto(txBody.freeze);
+      if (networkFreeze) {
+        return {
+          type: "FREEZE",
+          humanReadableType: "Network Freeze",
+          freeze: networkFreeze
+        };
+      }
+    }
+    if (txBody.systemDelete) {
+      const systemDelete = this.parseSystemDeleteFromProto(txBody.systemDelete);
+      if (systemDelete) {
+        return {
+          type: "SYSTEMDELETE",
+          humanReadableType: "System Delete",
+          systemDelete
+        };
+      }
+    }
+    if (txBody.systemUndelete) {
+      const systemUndelete = this.parseSystemUndeleteFromProto(
+        txBody.systemUndelete
       );
+      if (systemUndelete) {
+        return {
+          type: "SYSTEMUNDELETE",
+          humanReadableType: "System Undelete",
+          systemUndelete
+        };
+      }
     }
-    throw error;
-  }
-}
-function createPlaintextConversationHandle(client, sessionId, summary, defaultAuth, context) {
-  const uaid = context?.uaid?.trim();
-  const agentUrl = context?.agentUrl?.trim();
-  const fetchHistory = async (options) => {
-    const snapshot = await client.fetchHistorySnapshot(sessionId, options);
-    if (snapshot.decryptedHistory) {
-      return snapshot.decryptedHistory;
+    if (txBody.nodeCreate) {
+      const nodeCreate = this.parseNodeCreateFromProto(txBody.nodeCreate);
+      if (nodeCreate) {
+        return {
+          type: "NODECREATE",
+          humanReadableType: "Node Create",
+          nodeCreate
+        };
+      }
     }
-    return snapshot.history.map((entry) => ({
-      entry,
-      plaintext: entry.content
-    }));
-  };
-  return {
-    sessionId,
-    mode: "plaintext",
-    summary: summary ?? null,
-    send: async (options) => {
-      const plaintext = options.plaintext;
-      if (!plaintext || plaintext.trim().length === 0) {
-        throw new Error("plaintext is required for chat messages");
+    if (txBody.nodeUpdate) {
+      const nodeUpdate = this.parseNodeUpdateFromProto(txBody.nodeUpdate);
+      if (nodeUpdate) {
+        return {
+          type: "NODEUPDATE",
+          humanReadableType: "Node Update",
+          nodeUpdate
+        };
       }
-      const message = options.message ?? plaintext;
-      return sendMessage(client, {
-        sessionId,
-        message,
-        streaming: options.streaming,
-        auth: options.auth ?? defaultAuth,
-        uaid,
-        agentUrl
-      });
-    },
-    decryptHistoryEntry: (entry) => entry.content,
-    fetchHistory
-  };
-}
-async function compactHistory(client, payload) {
-  if (!payload.sessionId || payload.sessionId.trim().length === 0) {
-    throw new Error("sessionId is required to compact chat history");
-  }
-  const body = {};
-  if (typeof payload.preserveEntries === "number" && Number.isFinite(payload.preserveEntries) && payload.preserveEntries >= 0) {
-    body.preserveEntries = Math.floor(payload.preserveEntries);
-  }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(payload.sessionId)}/compact`,
-    {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    chatHistoryCompactionResponseSchema,
-    "chat history compaction response"
-  );
-}
-async function fetchEncryptionStatus(client, sessionId) {
-  if (!sessionId || sessionId.trim().length === 0) {
-    throw new Error("sessionId is required for encryption status");
-  }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(sessionId)}/encryption`,
-    {
-      method: "GET"
+    if (txBody.nodeDelete) {
+      const nodeDelete = this.parseNodeDeleteFromProto(txBody.nodeDelete);
+      if (nodeDelete) {
+        return {
+          type: "NODEDELETE",
+          humanReadableType: "Node Delete",
+          nodeDelete
+        };
+      }
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    sessionEncryptionStatusResponseSchema,
-    "session encryption status response"
-  );
-}
-async function postEncryptionHandshake(client, sessionId, payload) {
-  if (!sessionId || sessionId.trim().length === 0) {
-    throw new Error("sessionId is required for encryption handshake");
-  }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(sessionId)}/encryption-handshake`,
-    {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: {
-        role: payload.role,
-        keyType: payload.keyType,
-        ephemeralPublicKey: payload.ephemeralPublicKey,
-        longTermPublicKey: payload.longTermPublicKey,
-        signature: payload.signature,
-        uaid: payload.uaid,
-        userId: payload.userId,
-        ledgerAccountId: payload.ledgerAccountId,
-        metadata: payload.metadata
+    return {};
+  }
+  /**
+   * Extract utility data from Transaction internal fields
+   * This handles cases where data is stored in Transaction object internals
+   */
+  static parseFromTransactionInternals(transaction) {
+    try {
+      const tx = transaction;
+      if (hasTransactionType(transaction, "utilPrng")) {
+        const utilPrng = {};
+        if (tx._range && tx._range !== 0) {
+          utilPrng.range = tx._range;
+        }
+        return {
+          type: "PRNG",
+          humanReadableType: "Pseudo Random Number",
+          utilPrng
+        };
+      }
+      if (hasTransactionType(transaction, "freeze")) {
+        const networkFreeze = {};
+        if (tx._startTime) {
+          networkFreeze.startTime = tx._startTime.toString();
+        }
+        if (tx._endTime) {
+          networkFreeze.endTime = tx._endTime.toString();
+        }
+        if (tx._updateFile) {
+          networkFreeze.updateFile = tx._updateFile.toString();
+        }
+        if (tx._fileHash) {
+          networkFreeze.fileHash = Buffer.from(tx._fileHash).toString("hex");
+        }
+        if (tx._freezeType) {
+          networkFreeze.freezeType = tx._freezeType;
+        }
+        return {
+          type: "FREEZE",
+          humanReadableType: "Network Freeze",
+          freeze: networkFreeze
+        };
+      }
+      if (hasTransactionType(transaction, "systemDelete")) {
+        const systemDelete = {};
+        if (tx._fileId) {
+          systemDelete.fileId = tx._fileId.toString();
+        } else if (tx._contractId) {
+          systemDelete.contractId = tx._contractId.toString();
+        }
+        if (tx._expirationTime) {
+          systemDelete.expirationTime = tx._expirationTime.toString();
+        }
+        return {
+          type: "SYSTEMDELETE",
+          humanReadableType: "System Delete",
+          systemDelete
+        };
       }
+      if (hasTransactionType(transaction, "systemUndelete")) {
+        const systemUndelete = {};
+        if (tx._fileId) {
+          systemUndelete.fileId = tx._fileId.toString();
+        } else if (tx._contractId) {
+          systemUndelete.contractId = tx._contractId.toString();
+        }
+        return {
+          type: "SYSTEMUNDELETE",
+          humanReadableType: "System Undelete",
+          systemUndelete
+        };
+      }
+      return {};
+    } catch (error) {
+      return {};
     }
-  );
-  const response = client.parseWithSchema(
-    raw,
-    encryptionHandshakeResponseSchema,
-    "encryption handshake response"
-  );
-  return response.handshake;
-}
-async function sendMessage(client, payload) {
-  const body = {
-    message: payload.message
-  };
-  if (payload.streaming !== void 0) {
-    body.streaming = payload.streaming;
-  }
-  if (payload.idempotencyKey) {
-    body.idempotencyKey = payload.idempotencyKey;
-  }
-  if (payload.senderUaid) {
-    body.senderUaid = payload.senderUaid;
-  }
-  if (payload.transport) {
-    body.transport = payload.transport;
-  }
-  if (payload.auth) {
-    body.auth = serialiseAuthConfig(payload.auth);
-  }
-  if ("uaid" in payload) {
-    body.uaid = payload.uaid;
-  }
-  if ("sessionId" in payload && payload.sessionId) {
-    body.sessionId = payload.sessionId;
   }
-  if ("agentUrl" in payload && payload.agentUrl) {
-    body.agentUrl = payload.agentUrl;
-  }
-  let cipherEnvelope = payload.cipherEnvelope ?? null;
-  if (payload.encryption) {
-    const sessionIdForEncryption = payload.encryption.sessionId ?? (typeof body.sessionId === "string" ? body.sessionId : void 0);
-    if (!sessionIdForEncryption) {
-      throw new Error(
-        "sessionId is required when using encrypted chat payloads"
-      );
+  /**
+   * Parse Network Freeze from protobuf data
+   */
+  static parseNetworkFreezeFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.startTime?.seconds) {
+      data.startTime = `${Long.fromValue(
+        body.startTime.seconds
+      ).toString()}.${body.startTime.nanos ?? 0}`;
     }
-    if (!payload.encryption.recipients?.length) {
-      throw new Error("recipients are required for encrypted chat payloads");
+    if (body.updateFile) {
+      data.updateFile = new FileId(
+        body.updateFile.shardNum ?? 0,
+        body.updateFile.realmNum ?? 0,
+        body.updateFile.fileNum ?? 0
+      ).toString();
     }
-    cipherEnvelope = client.encryption.encryptCipherEnvelope({
-      ...payload.encryption,
-      sessionId: sessionIdForEncryption
-    });
-  }
-  if (cipherEnvelope) {
-    body.cipherEnvelope = toJsonObject(cipherEnvelope);
-  }
-  const raw = await client.requestJson("/chat/message", {
-    method: "POST",
-    body,
-    headers: { "content-type": "application/json" }
-  });
-  return client.parseWithSchema(
-    raw,
-    sendMessageResponseSchema,
-    "chat message response"
-  );
-}
-async function endSession(client, sessionId) {
-  const normalizedSessionId = sessionId?.trim();
-  if (!normalizedSessionId) {
-    throw new Error("sessionId is required to end a chat session");
-  }
-  const response = await client.request(
-    `/chat/session/${encodeURIComponent(normalizedSessionId)}`,
-    { method: "DELETE" }
-  );
-  if (response.status === 204) {
-    return {
-      message: "Session ended",
-      sessionId: normalizedSessionId,
-      state: "ended"
-    };
-  }
-  const contentType = response.headers?.get("content-type") ?? "";
-  if (!contentType.toLowerCase().includes("json")) {
-    await response.text();
-    return {
-      message: "Session ended",
-      sessionId: normalizedSessionId,
-      state: "ended"
-    };
-  }
-  const responseBody = await response.text();
-  if (responseBody.trim().length === 0) {
-    return {
-      message: "Session ended",
-      sessionId: normalizedSessionId,
-      state: "ended"
-    };
-  }
-  const raw = JSON.parse(responseBody);
-  return client.parseWithSchema(
-    raw,
-    chatSessionEndResponseSchema,
-    "chat session end response"
-  );
-}
-async function cancelSession(client, sessionId) {
-  const normalizedSessionId = sessionId?.trim();
-  if (!normalizedSessionId) {
-    throw new Error("sessionId is required to cancel a chat session");
-  }
-  const raw = await client.requestJson(
-    `/chat/session/${encodeURIComponent(normalizedSessionId)}/cancel`,
-    {
-      method: "POST"
+    if (body.fileHash && body.fileHash.length > 0) {
+      data.fileHash = Buffer.from(body.fileHash).toString("hex");
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    chatSessionEndResponseSchema,
-    "chat session cancel response"
-  );
-}
-async function retryMessage(client, messageId, payload) {
-  const normalizedMessageId = messageId?.trim();
-  const normalizedSessionId = payload.sessionId?.trim();
-  const normalizedMessage = payload.message?.trim();
-  if (!normalizedMessageId) {
-    throw new Error("messageId is required to retry a message");
-  }
-  if (!normalizedSessionId) {
-    throw new Error("sessionId is required to retry a message");
-  }
-  if (!normalizedMessage) {
-    throw new Error("message is required to retry a message");
-  }
-  const body = {
-    sessionId: normalizedSessionId,
-    message: payload.message
-  };
-  if (payload.streaming !== void 0) {
-    body.streaming = payload.streaming;
-  }
-  if (payload.transport) {
-    body.transport = payload.transport;
-  }
-  const uaid = payload.uaid?.trim();
-  const agentUrl = payload.agentUrl?.trim();
-  const idempotencyKey = payload.idempotencyKey?.trim();
-  const senderUaid = payload.senderUaid?.trim();
-  if (uaid) {
-    body.uaid = uaid;
-  }
-  if (agentUrl) {
-    body.agentUrl = agentUrl;
-  }
-  if (idempotencyKey) {
-    body.idempotencyKey = idempotencyKey;
-  }
-  if (senderUaid) {
-    body.senderUaid = senderUaid;
-  }
-  if (payload.auth) {
-    body.auth = serialiseAuthConfig(payload.auth);
+    if (body.freezeType !== void 0) {
+      const freezeTypes = [
+        "FREEZE_ONLY",
+        "PREPARE_UPGRADE",
+        "FREEZE_UPGRADE",
+        "FREEZE_ABORT"
+      ];
+      data.freezeType = freezeTypes[body.freezeType] || "FREEZE_ONLY";
+    }
+    return data;
+  }
+  /**
+   * Parse System Delete from protobuf data
+   */
+  static parseSystemDeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.fileID) {
+      data.fileId = new FileId(
+        body.fileID.shardNum ?? 0,
+        body.fileID.realmNum ?? 0,
+        body.fileID.fileNum ?? 0
+      ).toString();
+    } else if (body.contractID) {
+      data.contractId = new ContractId(
+        body.contractID.shardNum ?? 0,
+        body.contractID.realmNum ?? 0,
+        body.contractID.contractNum ?? 0
+      ).toString();
+    }
+    if (body.expirationTime?.seconds) {
+      data.expirationTime = Long.fromValue(
+        body.expirationTime.seconds
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Parse System Undelete from protobuf data
+   */
+  static parseSystemUndeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.fileID) {
+      data.fileId = new FileId(
+        body.fileID.shardNum ?? 0,
+        body.fileID.realmNum ?? 0,
+        body.fileID.fileNum ?? 0
+      ).toString();
+    } else if (body.contractID) {
+      data.contractId = new ContractId(
+        body.contractID.shardNum ?? 0,
+        body.contractID.realmNum ?? 0,
+        body.contractID.contractNum ?? 0
+      ).toString();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Create from protobuf data
+   */
+  static parseNodeCreateFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Update from protobuf data
+   */
+  static parseNodeUpdateFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
+  }
+  /**
+   * Parse Node Delete from protobuf data
+   */
+  static parseNodeDeleteFromProto(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.nodeId !== void 0) {
+      data.nodeId = Long.fromValue(body.nodeId).toNumber();
+    }
+    return data;
   }
-  let cipherEnvelope = payload.cipherEnvelope ?? null;
-  if (payload.encryption) {
-    if (!payload.encryption.recipients?.length) {
-      throw new Error("recipients are required for encrypted chat payloads");
+  static parseUtilPrng(body) {
+    if (!body) return void 0;
+    const data = {};
+    if (body.range && body.range !== 0) {
+      data.range = body.range;
     }
-    cipherEnvelope = client.encryption.encryptCipherEnvelope({
-      ...payload.encryption,
-      sessionId: payload.encryption.sessionId ?? normalizedSessionId
-    });
+    return data;
   }
-  if (cipherEnvelope) {
-    body.cipherEnvelope = toJsonObject(cipherEnvelope);
+  static parseFreeze(body) {
+    return this.parseNetworkFreezeFromProto(body);
+  }
+  /**
+   * Parse Utility/System Service transaction from Transaction object
+   * This is the unified entry point that delegates to the comprehensive parsing logic
+   */
+  static parseFromTransactionObject(transaction) {
+    return this.parseUtilTransaction(transaction);
   }
-  const raw = await client.requestJson(
-    `/chat/message/${encodeURIComponent(normalizedMessageId)}/retry`,
-    {
-      method: "POST",
-      body,
-      headers: { "content-type": "application/json" }
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    sendMessageResponseSchema,
-    "chat retry response"
-  );
 }
 export {
-  acceptConversation,
-  cancelSession,
-  checkChatReadiness,
-  compactHistory,
-  createChatApi,
-  createPlaintextConversationHandle,
-  createSession,
-  endSession,
-  fetchEncryptionStatus,
-  postEncryptionHandshake,
-  resumeSession,
-  retryMessage,
-  sendMessage,
-  startChat,
-  startConversation
+  UtilParser
 };
 //# sourceMappingURL=standards-sdk.es177.js.map