@hashgraphonline/standards-sdk 0.1.172 → 0.1.174

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

@@ -1,79 +1,203 @@
-import { proto } from "@hashgraph/proto";
-import { ContractId } from "@hashgraph/sdk";
-import { Buffer } from "buffer";
-function parseKey(key) {
-  if (!key) {
-    return void 0;
+import { parseSemicolonFields } from "./standards-sdk.es173.js";
+const ANS_HCS27_REGISTRY = "ans";
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asString(value) {
+  if (typeof value !== "string") {
+    return null;
   }
-  if (key.contractID) {
-    return `ContractID: ${new ContractId(
-      key.contractID.shardNum ?? 0,
-      key.contractID.realmNum ?? 0,
-      key.contractID.contractNum ?? 0
-    ).toString()}`;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
   }
-  if (key.ed25519) {
-    return `ED25519: ${Buffer.from(key.ed25519).toString("hex")}`;
+  return trimmed;
+}
+function isSemver(value) {
+  return /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(
+    value
+  );
+}
+function normalizeAnsVersion(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
   }
-  if (key.ECDSASecp256k1) {
-    return `ECDSA_secp256k1: ${Buffer.from(key.ECDSASecp256k1).toString(
-      "hex"
-    )}`;
+  const withoutPrefix = trimmed.startsWith("v") || trimmed.startsWith("V") ? trimmed.slice(1) : trimmed;
+  if (!isSemver(withoutPrefix)) {
+    return null;
   }
-  if (key?.keyList?.keys?.length > 0) {
-    const keys = key.keyList.keys.map((k) => parseKey(k)).filter(Boolean);
-    return `KeyList (${keys.length} keys): [${keys.join(", ")}]`;
+  return withoutPrefix;
+}
+function parseAnsDnsTxtRecord(rawRecord) {
+  const fields = parseSemicolonFields(rawRecord);
+  const version = fields["v"];
+  const urlValue = fields["url"];
+  if (!version || !urlValue || version.toLowerCase() !== "ans1") {
+    return null;
   }
-  if (key?.thresholdKey?.keys?.keys?.length > 0) {
-    const keys = key.thresholdKey.keys.keys.map((k) => parseKey(k)).filter(Boolean);
-    return `ThresholdKey (${key.thresholdKey.threshold} of ${keys.length}): [${keys.join(", ")}]`;
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(urlValue);
+  } catch {
+    return null;
   }
-  if (key.delegatableContractId) {
-    return `DelegatableContractID: ${new ContractId(
-      key.delegatableContractId.shardNum ?? 0,
-      key.delegatableContractId.realmNum ?? 0,
-      key.delegatableContractId.contractNum ?? 0
-    ).toString()}`;
+  if (parsedUrl.protocol.toLowerCase() !== "https:") {
+    return null;
   }
-  if (Object.keys(key).length === 0) {
-    return "Empty Key Structure";
+  const rawAnsVersion = fields["version"];
+  let normalizedAnsVersion;
+  if (rawAnsVersion !== void 0) {
+    const parsedVersion = normalizeAnsVersion(rawAnsVersion);
+    if (!parsedVersion) {
+      return null;
+    }
+    normalizedAnsVersion = parsedVersion;
   }
-  return "Unknown or Unset Key Type";
+  return {
+    version: normalizedAnsVersion,
+    url: parsedUrl.toString()
+  };
 }
-function extractTransactionBody(transaction) {
-  try {
-    const bytes = transaction.toBytes ? transaction.toBytes() : void 0;
-    if (!bytes) {
-      return null;
+function isValidAnsProfileVersion(value) {
+  return !!value && normalizeAnsVersion(value) !== null;
+}
+function hasProtocolPathSegment(pathname, protocol) {
+  const normalizedProtocol = protocol.trim().toLowerCase();
+  if (!normalizedProtocol) {
+    return false;
+  }
+  const pathSegments = pathname.split("/").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+  for (const segment of pathSegments) {
+    if (segment.toLowerCase() === normalizedProtocol) {
+      return true;
     }
-    const decoded = proto.TransactionList.decode(bytes);
-    if (!decoded.transactionList || decoded.transactionList.length === 0) {
-      return null;
+  }
+  return false;
+}
+function extractEndpointCandidates(endpoints, supportedSchemes) {
+  const candidates = [];
+  for (const [key, value] of Object.entries(endpoints)) {
+    if (!isObjectRecord(value)) {
+      continue;
+    }
+    const endpoint = asString(value["url"]);
+    if (!endpoint) {
+      continue;
     }
-    const tx = decoded.transactionList[0];
-    if (tx.bodyBytes && tx.bodyBytes.length > 0) {
-      return proto.TransactionBody.decode(tx.bodyBytes);
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(endpoint);
+    } catch {
+      continue;
     }
-    if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {
-      const signedTx = proto.SignedTransaction.decode(
-        tx.signedTransactionBytes
-      );
-      if (signedTx.bodyBytes) {
-        return proto.TransactionBody.decode(signedTx.bodyBytes);
-      }
+    const scheme = parsedUrl.protocol.replace(/:$/, "").toLowerCase();
+    if (!supportedSchemes.has(scheme)) {
+      continue;
     }
+    candidates.push({
+      key,
+      endpointUrl: parsedUrl.toString(),
+      parsedUrl
+    });
+  }
+  return candidates;
+}
+function validateAnsHcs27Hints(input) {
+  if (!isObjectRecord(input)) {
+    return void 0;
+  }
+  const checkpointTopicId = asString(input["checkpoint_topic_id"]);
+  const registry = asString(input["registry"]);
+  const logId = asString(input["log_id"]);
+  if (!checkpointTopicId || !registry || !logId || registry !== ANS_HCS27_REGISTRY) {
+    return void 0;
+  }
+  const checkpointUri = asString(input["checkpoint_uri"]) ?? void 0;
+  const viewerUri = asString(input["viewer_uri"]) ?? void 0;
+  return {
+    checkpointTopicId,
+    registry,
+    logId,
+    checkpointUri,
+    viewerUri
+  };
+}
+function validateHcs28Hints(input) {
+  if (!isObjectRecord(input)) {
+    return void 0;
+  }
+  const directoryTopicId = asString(input["directory_topic_id"]);
+  const tId = asString(input["t_id"]);
+  const agentId = asString(input["agent_id"]);
+  if (!directoryTopicId || !tId || !agentId) {
+    return void 0;
+  }
+  const proofProfile = asString(input["proof_profile"]) ?? void 0;
+  return {
+    directoryTopicId,
+    tId,
+    agentId,
+    proofProfile
+  };
+}
+function parseTransparencyHints(input) {
+  if (!isObjectRecord(input)) {
+    return void 0;
+  }
+  const hcs27 = validateAnsHcs27Hints(input["hcs27"]);
+  const hcs28 = validateHcs28Hints(input["hcs28"]);
+  if (!hcs27 && !hcs28) {
+    return void 0;
+  }
+  return {
+    hcs27,
+    hcs28
+  };
+}
+function parseAnsAgentCard(input) {
+  if (!isObjectRecord(input)) {
     return null;
-  } catch (error) {
+  }
+  const ansName = asString(input["ansName"]);
+  const endpoints = input["endpoints"];
+  if (!ansName || !isObjectRecord(endpoints)) {
     return null;
   }
+  return {
+    ansName,
+    endpoints,
+    transparencyHints: parseTransparencyHints(input["transparency"])
+  };
 }
-function hasTransactionType(transaction, transactionField) {
-  const txBody = extractTransactionBody(transaction);
-  return !!(txBody && txBody[transactionField]);
+function selectPreferredEndpoint(candidates, protocol) {
+  if (candidates.length === 0) {
+    return null;
+  }
+  const sortedCandidates = [...candidates].sort(
+    (a, b) => a.key.localeCompare(b.key)
+  );
+  const protocolMatches = sortedCandidates.filter(
+    (candidate) => hasProtocolPathSegment(candidate.parsedUrl.pathname, protocol)
+  );
+  if (protocolMatches.length > 0) {
+    return protocolMatches[0];
+  }
+  return sortedCandidates[0];
+}
+function toErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return null;
 }
 export {
-  extractTransactionBody,
-  hasTransactionType,
-  parseKey
+  extractEndpointCandidates,
+  isValidAnsProfileVersion,
+  normalizeAnsVersion,
+  parseAnsAgentCard,
+  parseAnsDnsTxtRecord,
+  selectPreferredEndpoint,
+  toErrorMessage
 };
 //# sourceMappingURL=standards-sdk.es174.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es174.js","sources":["../../src/utils/parsers/parser-utils.ts"],"sourcesContent":["import { proto } from '@hashgraph/proto';\nimport { ContractId, Transaction } from '@hashgraph/sdk';\nimport { Buffer } from 'buffer';\n\nexport function parseKey(\n  key: proto.IKey | null | undefined,\n): string | undefined {\n  if (!key) {\n    return undefined;\n  }\n\n  if (key.contractID) {\n    return `ContractID: ${new ContractId(\n      key.contractID.shardNum ?? 0,\n      key.contractID.realmNum ?? 0,\n      key.contractID.contractNum ?? 0,\n    ).toString()}`;\n  }\n  if (key.ed25519) {\n    return `ED25519: ${Buffer.from(key.ed25519).toString('hex')}`;\n  }\n  if (key.ECDSASecp256k1) {\n    return `ECDSA_secp256k1: ${Buffer.from(key.ECDSASecp256k1).toString(\n      'hex',\n    )}`;\n  }\n  if (key?.keyList?.keys?.length > 0) {\n    const keys = key.keyList.keys.map(k => parseKey(k)).filter(Boolean);\n    return `KeyList (${keys.length} keys): [${keys.join(', ')}]`;\n  }\n  if (key?.thresholdKey?.keys?.keys?.length > 0) {\n    const keys = key.thresholdKey.keys.keys\n      .map(k => parseKey(k))\n      .filter(Boolean);\n    return `ThresholdKey (${key.thresholdKey.threshold} of ${\n      keys.length\n    }): [${keys.join(', ')}]`;\n  }\n  if (key.delegatableContractId) {\n    return `DelegatableContractID: ${new ContractId(\n      key.delegatableContractId.shardNum ?? 0,\n      key.delegatableContractId.realmNum ?? 0,\n      key.delegatableContractId.contractNum ?? 0,\n    ).toString()}`;\n  }\n  if (Object.keys(key).length === 0) {\n    return 'Empty Key Structure';\n  }\n\n  return 'Unknown or Unset Key Type';\n}\n\n/**\n * Extract TransactionBody from Transaction object using protobuf parsing\n * This replaces fragile constructor name checking with reliable protobuf data\n */\nexport function extractTransactionBody(\n  transaction: Transaction,\n): proto.ITransactionBody | null {\n  try {\n    const bytes = transaction.toBytes ? transaction.toBytes() : undefined;\n    if (!bytes) {\n      return null;\n    }\n\n    const decoded = proto.TransactionList.decode(bytes);\n    if (!decoded.transactionList || decoded.transactionList.length === 0) {\n      return null;\n    }\n\n    const tx = decoded.transactionList[0];\n\n    if (tx.bodyBytes && tx.bodyBytes.length > 0) {\n      return proto.TransactionBody.decode(tx.bodyBytes);\n    }\n\n    if (tx.signedTransactionBytes && tx.signedTransactionBytes.length > 0) {\n      const signedTx = proto.SignedTransaction.decode(\n        tx.signedTransactionBytes,\n      );\n      if (signedTx.bodyBytes) {\n        return proto.TransactionBody.decode(signedTx.bodyBytes);\n      }\n    }\n\n    return null;\n  } catch (error) {\n    return null;\n  }\n}\n\n/**\n * Check if transaction has specific transaction type using protobuf data\n * This replaces constructor name checking with reliable protobuf field detection\n */\nexport function hasTransactionType(\n  transaction: Transaction,\n  transactionField: keyof proto.ITransactionBody,\n): boolean {\n  const txBody = extractTransactionBody(transaction);\n  return !!(txBody && txBody[transactionField]);\n}\n"],"names":[],"mappings":";;;AAIO,SAAS,SACd,KACoB;AACpB,MAAI,CAAC,KAAK;AACR,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,YAAY;AAClB,WAAO,eAAe,IAAI;AAAA,MACxB,IAAI,WAAW,YAAY;AAAA,MAC3B,IAAI,WAAW,YAAY;AAAA,MAC3B,IAAI,WAAW,eAAe;AAAA,IAAA,EAC9B,UAAU;AAAA,EACd;AACA,MAAI,IAAI,SAAS;AACf,WAAO,YAAY,OAAO,KAAK,IAAI,OAAO,EAAE,SAAS,KAAK,CAAC;AAAA,EAC7D;AACA,MAAI,IAAI,gBAAgB;AACtB,WAAO,oBAAoB,OAAO,KAAK,IAAI,cAAc,EAAE;AAAA,MACzD;AAAA,IAAA,CACD;AAAA,EACH;AACA,MAAI,KAAK,SAAS,MAAM,SAAS,GAAG;AAClC,UAAM,OAAO,IAAI,QAAQ,KAAK,IAAI,CAAA,MAAK,SAAS,CAAC,CAAC,EAAE,OAAO,OAAO;AAClE,WAAO,YAAY,KAAK,MAAM,YAAY,KAAK,KAAK,IAAI,CAAC;AAAA,EAC3D;AACA,MAAI,KAAK,cAAc,MAAM,MAAM,SAAS,GAAG;AAC7C,UAAM,OAAO,IAAI,aAAa,KAAK,KAChC,IAAI,CAAA,MAAK,SAAS,CAAC,CAAC,EACpB,OAAO,OAAO;AACjB,WAAO,iBAAiB,IAAI,aAAa,SAAS,OAChD,KAAK,MACP,OAAO,KAAK,KAAK,IAAI,CAAC;AAAA,EACxB;AACA,MAAI,IAAI,uBAAuB;AAC7B,WAAO,0BAA0B,IAAI;AAAA,MACnC,IAAI,sBAAsB,YAAY;AAAA,MACtC,IAAI,sBAAsB,YAAY;AAAA,MACtC,IAAI,sBAAsB,eAAe;AAAA,IAAA,EACzC,UAAU;AAAA,EACd;AACA,MAAI,OAAO,KAAK,GAAG,EAAE,WAAW,GAAG;AACjC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAMO,SAAS,uBACd,aAC+B;AAC/B,MAAI;AACF,UAAM,QAAQ,YAAY,UAAU,YAAY,YAAY;AAC5D,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AAEA,UAAM,UAAU,MAAM,gBAAgB,OAAO,KAAK;AAClD,QAAI,CAAC,QAAQ,mBAAmB,QAAQ,gBAAgB,WAAW,GAAG;AACpE,aAAO;AAAA,IACT;AAEA,UAAM,KAAK,QAAQ,gBAAgB,CAAC;AAEpC,QAAI,GAAG,aAAa,GAAG,UAAU,SAAS,GAAG;AAC3C,aAAO,MAAM,gBAAgB,OAAO,GAAG,SAAS;AAAA,IAClD;AAEA,QAAI,GAAG,0BAA0B,GAAG,uBAAuB,SAAS,GAAG;AACrE,YAAM,WAAW,MAAM,kBAAkB;AAAA,QACvC,GAAG;AAAA,MAAA;AAEL,UAAI,SAAS,WAAW;AACtB,eAAO,MAAM,gBAAgB,OAAO,SAAS,SAAS;AAAA,MACxD;AAAA,IACF;AAEA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,WAAO;AAAA,EACT;AACF;AAMO,SAAS,mBACd,aACA,kBACS;AACT,QAAM,SAAS,uBAAuB,WAAW;AACjD,SAAO,CAAC,EAAE,UAAU,OAAO,gBAAgB;AAC7C;"}
+{"version":3,"file":"standards-sdk.es174.js","sources":["../../src/hcs-14/resolvers/ans-dns-web-profile-utils.ts"],"sourcesContent":["import type {\n  ProfileResolutionHcs27TransparencyHints,\n  ProfileResolutionHcs28TransparencyHints,\n  ProfileResolutionTransparencyHints,\n} from './types';\nimport { parseSemicolonFields } from './profile-utils';\n\nexport interface AnsDnsTxtRecord {\n  version?: string;\n  url: string;\n}\n\nexport interface AnsEndpointCandidate {\n  key: string;\n  endpointUrl: string;\n  parsedUrl: URL;\n}\n\nexport interface ParsedAnsAgentCard {\n  ansName: string;\n  endpoints: Record<string, unknown>;\n  transparencyHints?: ProfileResolutionTransparencyHints;\n}\n\nconst ANS_HCS27_REGISTRY = 'ans';\n\nfunction isObjectRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n\nfunction asString(value: unknown): string | null {\n  if (typeof value !== 'string') {\n    return null;\n  }\n  const trimmed = value.trim();\n  if (!trimmed) {\n    return null;\n  }\n  return trimmed;\n}\n\nfunction isSemver(value: string): boolean {\n  return /^(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)\\.(?:0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$/.test(\n    value,\n  );\n}\n\nexport function normalizeAnsVersion(value: string): string | null {\n  const trimmed = value.trim();\n  if (!trimmed) {\n    return null;\n  }\n  const withoutPrefix =\n    trimmed.startsWith('v') || trimmed.startsWith('V')\n      ? trimmed.slice(1)\n      : trimmed;\n  if (!isSemver(withoutPrefix)) {\n    return null;\n  }\n  return withoutPrefix;\n}\n\nexport function parseAnsDnsTxtRecord(\n  rawRecord: string,\n): AnsDnsTxtRecord | null {\n  const fields = parseSemicolonFields(rawRecord);\n  const version = fields['v'];\n  const urlValue = fields['url'];\n  if (!version || !urlValue || version.toLowerCase() !== 'ans1') {\n    return null;\n  }\n\n  let parsedUrl: URL;\n  try {\n    parsedUrl = new URL(urlValue);\n  } catch {\n    return null;\n  }\n\n  if (parsedUrl.protocol.toLowerCase() !== 'https:') {\n    return null;\n  }\n\n  const rawAnsVersion = fields['version'];\n  let normalizedAnsVersion: string | undefined;\n  if (rawAnsVersion !== undefined) {\n    const parsedVersion = normalizeAnsVersion(rawAnsVersion);\n    if (!parsedVersion) {\n      return null;\n    }\n    normalizedAnsVersion = parsedVersion;\n  }\n\n  return {\n    version: normalizedAnsVersion,\n    url: parsedUrl.toString(),\n  };\n}\n\nexport function isValidAnsProfileVersion(value: string | undefined): boolean {\n  return !!value && normalizeAnsVersion(value) !== null;\n}\n\nfunction hasProtocolPathSegment(pathname: string, protocol: string): boolean {\n  const normalizedProtocol = protocol.trim().toLowerCase();\n  if (!normalizedProtocol) {\n    return false;\n  }\n\n  const pathSegments = pathname\n    .split('/')\n    .map(segment => segment.trim())\n    .filter(segment => segment.length > 0);\n  for (const segment of pathSegments) {\n    if (segment.toLowerCase() === normalizedProtocol) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport function extractEndpointCandidates(\n  endpoints: Record<string, unknown>,\n  supportedSchemes: Set<string>,\n): AnsEndpointCandidate[] {\n  const candidates: AnsEndpointCandidate[] = [];\n  for (const [key, value] of Object.entries(endpoints)) {\n    if (!isObjectRecord(value)) {\n      continue;\n    }\n    const endpoint = asString(value['url']);\n    if (!endpoint) {\n      continue;\n    }\n\n    let parsedUrl: URL;\n    try {\n      parsedUrl = new URL(endpoint);\n    } catch {\n      continue;\n    }\n\n    const scheme = parsedUrl.protocol.replace(/:$/, '').toLowerCase();\n    if (!supportedSchemes.has(scheme)) {\n      continue;\n    }\n\n    candidates.push({\n      key,\n      endpointUrl: parsedUrl.toString(),\n      parsedUrl,\n    });\n  }\n\n  return candidates;\n}\n\nfunction validateAnsHcs27Hints(\n  input: unknown,\n): ProfileResolutionHcs27TransparencyHints | undefined {\n  if (!isObjectRecord(input)) {\n    return undefined;\n  }\n  const checkpointTopicId = asString(input['checkpoint_topic_id']);\n  const registry = asString(input['registry']);\n  const logId = asString(input['log_id']);\n  if (\n    !checkpointTopicId ||\n    !registry ||\n    !logId ||\n    registry !== ANS_HCS27_REGISTRY\n  ) {\n    return undefined;\n  }\n  const checkpointUri = asString(input['checkpoint_uri']) ?? undefined;\n  const viewerUri = asString(input['viewer_uri']) ?? undefined;\n  return {\n    checkpointTopicId,\n    registry,\n    logId,\n    checkpointUri,\n    viewerUri,\n  };\n}\n\nfunction validateHcs28Hints(\n  input: unknown,\n): ProfileResolutionHcs28TransparencyHints | undefined {\n  if (!isObjectRecord(input)) {\n    return undefined;\n  }\n  const directoryTopicId = asString(input['directory_topic_id']);\n  const tId = asString(input['t_id']);\n  const agentId = asString(input['agent_id']);\n  if (!directoryTopicId || !tId || !agentId) {\n    return undefined;\n  }\n  const proofProfile = asString(input['proof_profile']) ?? undefined;\n  return {\n    directoryTopicId,\n    tId,\n    agentId,\n    proofProfile,\n  };\n}\n\nfunction parseTransparencyHints(\n  input: unknown,\n): ProfileResolutionTransparencyHints | undefined {\n  if (!isObjectRecord(input)) {\n    return undefined;\n  }\n  const hcs27 = validateAnsHcs27Hints(input['hcs27']);\n  const hcs28 = validateHcs28Hints(input['hcs28']);\n  if (!hcs27 && !hcs28) {\n    return undefined;\n  }\n  return {\n    hcs27,\n    hcs28,\n  };\n}\n\nexport function parseAnsAgentCard(input: unknown): ParsedAnsAgentCard | null {\n  if (!isObjectRecord(input)) {\n    return null;\n  }\n  const ansName = asString(input['ansName']);\n  const endpoints = input['endpoints'];\n  if (!ansName || !isObjectRecord(endpoints)) {\n    return null;\n  }\n  return {\n    ansName,\n    endpoints,\n    transparencyHints: parseTransparencyHints(input['transparency']),\n  };\n}\n\nexport function selectPreferredEndpoint(\n  candidates: AnsEndpointCandidate[],\n  protocol: string,\n): AnsEndpointCandidate | null {\n  if (candidates.length === 0) {\n    return null;\n  }\n\n  const sortedCandidates = [...candidates].sort((a, b) =>\n    a.key.localeCompare(b.key),\n  );\n  const protocolMatches = sortedCandidates.filter(candidate =>\n    hasProtocolPathSegment(candidate.parsedUrl.pathname, protocol),\n  );\n  if (protocolMatches.length > 0) {\n    return protocolMatches[0];\n  }\n  return sortedCandidates[0];\n}\n\nexport function toErrorMessage(error: unknown): string | null {\n  if (error instanceof Error && error.message) {\n    return error.message;\n  }\n  return null;\n}\n"],"names":[],"mappings":"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"}

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

@@ -1,175 +1,142 @@
-import * as path from "path";
 import { Buffer } from "buffer";
-import { randomBytes } from "crypto";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { registerEncryptionKeyResponseSchema } from "./standards-sdk.es145.js";
-import { optionalImport } from "./standards-sdk.es163.js";
-const getFs = async () => {
-  const fsModule = await optionalImport("node:fs");
-  if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
-    return fsModule;
-  }
-  return null;
-};
-async function registerEncryptionKey(client, payload) {
-  const raw = await client.requestJson("/encryption/keys", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: payload
-  });
-  return client.parseWithSchema(
-    raw,
-    registerEncryptionKeyResponseSchema,
-    "register encryption key response"
-  );
-}
-function normalizeAutoRegisterIdentity(config) {
-  const identity = {};
-  if (config.uaid) {
-    identity.uaid = config.uaid;
-  }
-  if (config.ledgerAccountId) {
-    identity.ledgerAccountId = config.ledgerAccountId;
-    if (config.ledgerNetwork) {
-      identity.ledgerNetwork = config.ledgerNetwork;
-    }
+import { chatHistorySnapshotResponseSchema } from "./standards-sdk.es160.js";
+function identitiesMatch(a, b) {
+  if (!a && !b) {
+    return true;
   }
-  if (config.email) {
-    identity.email = config.email;
+  if (!a || !b) {
+    return false;
   }
-  if (identity.uaid || identity.ledgerAccountId || identity.email) {
-    return identity;
+  if (a.uaid && b.uaid && a.uaid.toLowerCase() === b.uaid.toLowerCase()) {
+    return true;
   }
-  return null;
-}
-function derivePublicKeyFromPrivateKey(client, privateKey) {
-  const normalized = client.hexToBuffer(privateKey);
-  const publicKey = secp256k1.getPublicKey(normalized, true);
-  return Buffer.from(publicKey).toString("hex");
-}
-async function resolveAutoRegisterKeyMaterial(client, config) {
-  if (config.publicKey?.trim()) {
-    return { publicKey: config.publicKey.trim() };
-  }
-  let privateKey = config.privateKey?.trim();
-  const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
-    privateKey = process.env[envVar]?.trim();
-  }
-  if (!privateKey && config.generateIfMissing) {
-    const pair = await client.generateEncryptionKeyPair({
-      keyType: config.keyType ?? "secp256k1",
-      envVar,
-      envPath: config.envPath,
-      overwrite: config.overwriteEnv
-    });
-    return { publicKey: pair.publicKey, privateKey: pair.privateKey };
+  if (a.ledgerAccountId && b.ledgerAccountId && a.ledgerAccountId.toLowerCase() === b.ledgerAccountId.toLowerCase()) {
+    return true;
+  }
+  if (a.userId && b.userId && a.userId === b.userId) {
+    return true;
   }
-  if (privateKey) {
-    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);
-    return { publicKey, privateKey };
+  if (a.email && b.email && a.email.toLowerCase() === b.email.toLowerCase()) {
+    return true;
   }
-  return null;
+  return false;
 }
-async function autoRegisterEncryptionKey(client, config) {
-  const identity = normalizeAutoRegisterIdentity(config);
-  if (!identity) {
-    throw new Error(
-      "Auto-registration requires uaid, ledgerAccountId, or email"
-    );
+async function fetchHistorySnapshot(conversationContexts, client, sessionId, options) {
+  if (!sessionId || sessionId.trim().length === 0) {
+    throw new Error("sessionId is required to fetch chat history");
+  }
+  const raw = await client.requestJson(
+    `/chat/session/${encodeURIComponent(sessionId)}/history`,
+    {
+      method: "GET"
+    }
+  );
+  const snapshot = client.parseWithSchema(
+    raw,
+    chatHistorySnapshotResponseSchema,
+    "chat history snapshot response"
+  );
+  return attachDecryptedHistory(
+    conversationContexts,
+    client,
+    sessionId,
+    snapshot,
+    options
+  );
+}
+function attachDecryptedHistory(conversationContexts, client, sessionId, snapshot, options) {
+  const shouldDecrypt = options?.decrypt !== void 0 ? options.decrypt : client.encryptionOptions?.autoDecryptHistory === true;
+  if (!shouldDecrypt) {
+    return snapshot;
+  }
+  const requiresContext = snapshot.history.some(
+    (entry) => Boolean(entry.cipherEnvelope)
+  );
+  if (!requiresContext) {
+    return {
+      ...snapshot,
+      decryptedHistory: snapshot.history.map((entry) => ({
+        entry,
+        plaintext: entry.content
+      }))
+    };
   }
-  const material = await resolveAutoRegisterKeyMaterial(client, config);
-  if (!material) {
+  const context = resolveDecryptionContext(
+    conversationContexts,
+    client,
+    sessionId,
+    options
+  );
+  if (!context) {
     throw new Error(
-      "Unable to resolve encryption public key for auto-registration"
+      "Unable to decrypt chat history: encryption context unavailable"
     );
   }
-  await registerEncryptionKey(client, {
-    keyType: config.keyType ?? "secp256k1",
-    publicKey: material.publicKey,
-    ...identity
-  });
-  return material;
-}
-async function ensureAgentEncryptionKey(client, options) {
-  return autoRegisterEncryptionKey(client, {
-    ...options,
-    uaid: options.uaid
-  });
+  const decryptedHistory = snapshot.history.map((entry) => ({
+    entry,
+    plaintext: decryptHistoryEntryFromContext(client, entry, context)
+  }));
+  return { ...snapshot, decryptedHistory };
 }
-function createEncryptionApi(client) {
-  return {
-    registerKey: (payload) => registerEncryptionKey(client, payload),
-    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),
-    deriveSharedSecret: (options) => client.deriveSharedSecret(options),
-    encryptCipherEnvelope: (options) => client.buildCipherEnvelope(options),
-    decryptCipherEnvelope: (options) => client.openCipherEnvelope(options),
-    ensureAgentKey: (options) => ensureAgentEncryptionKey(client, options)
+function registerConversationContextForEncryption(conversationContexts, context) {
+  const normalized = {
+    sessionId: context.sessionId,
+    sharedSecret: Buffer.from(context.sharedSecret),
+    identity: context.identity ? { ...context.identity } : void 0
   };
+  const entries = conversationContexts.get(context.sessionId) ?? [];
+  const existingIndex = entries.findIndex(
+    (existing) => identitiesMatch(existing.identity, normalized.identity)
+  );
+  if (existingIndex >= 0) {
+    entries[existingIndex] = normalized;
+  } else {
+    entries.push(normalized);
+  }
+  conversationContexts.set(context.sessionId, entries);
 }
-async function bootstrapEncryptionOptions(client, options) {
-  if (!options?.autoRegister || options.autoRegister.enabled === false) {
+function resolveDecryptionContext(conversationContexts, client, sessionId, options) {
+  if (options?.sharedSecret) {
+    return {
+      sessionId,
+      sharedSecret: client.normalizeSharedSecret(options.sharedSecret),
+      identity: options.identity
+    };
+  }
+  const contexts = conversationContexts.get(sessionId);
+  if (!contexts || contexts.length === 0) {
     return null;
   }
-  return autoRegisterEncryptionKey(client, options.autoRegister);
-}
-async function generateEncryptionKeyPair(client, options = {}) {
-  client.assertNodeRuntime("generateEncryptionKeyPair");
-  const keyType = options.keyType ?? "secp256k1";
-  if (keyType !== "secp256k1") {
-    throw new Error("Only secp256k1 key generation is supported currently");
-  }
-  const privateKeyBytes = randomBytes(32);
-  const privateKey = Buffer.from(privateKeyBytes).toString("hex");
-  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
-  const publicKey = Buffer.from(publicKeyBytes).toString("hex");
-  const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
-  const resolvedPath = options.envPath ? path.resolve(options.envPath) : void 0;
-  if (resolvedPath) {
-    const fsModule = await getFs();
-    if (!fsModule) {
-      throw new Error(
-        "File system module is not available; cannot write encryption key env file"
-      );
-    }
-    const envLine = `${envVar}=${privateKey}`;
-    if (fsModule.existsSync(resolvedPath)) {
-      const content = fsModule.readFileSync(resolvedPath, "utf-8");
-      const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
-      if (lineRegex.test(content)) {
-        if (!options.overwrite) {
-          throw new Error(
-            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
-          );
-        }
-        const updated = content.replace(lineRegex, envLine);
-        fsModule.writeFileSync(resolvedPath, updated);
-      } else {
-        const needsNewline = !content.endsWith("\n");
-        fsModule.appendFileSync(
-          resolvedPath,
-          `${needsNewline ? "\n" : ""}${envLine}
-`
-        );
-      }
-    } else {
-      fsModule.writeFileSync(resolvedPath, `${envLine}
-`);
+  if (options?.identity) {
+    const match = contexts.find(
+      (context) => identitiesMatch(context.identity, options.identity)
+    );
+    if (match) {
+      return match;
     }
   }
-  return {
-    privateKey,
-    publicKey,
-    envPath: resolvedPath,
-    envVar
-  };
+  return contexts[0];
+}
+function decryptHistoryEntryFromContext(client, entry, context) {
+  const envelope = entry.cipherEnvelope;
+  if (!envelope) {
+    return entry.content;
+  }
+  const secret = Buffer.from(context.sharedSecret);
+  try {
+    return client.encryption.decryptCipherEnvelope({
+      envelope,
+      sharedSecret: secret
+    });
+  } catch (_error) {
+    return null;
+  }
 }
 export {
-  autoRegisterEncryptionKey,
-  bootstrapEncryptionOptions,
-  createEncryptionApi,
-  ensureAgentEncryptionKey,
-  generateEncryptionKeyPair,
-  registerEncryptionKey
+  attachDecryptedHistory,
+  decryptHistoryEntryFromContext,
+  fetchHistorySnapshot,
+  registerConversationContextForEncryption,
+  resolveDecryptionContext
 };
 //# sourceMappingURL=standards-sdk.es175.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es175.js","sources":["../../src/services/registry-broker/client/encryption.ts"],"sourcesContent":["import * as path from 'path';\nimport { Buffer } from 'buffer';\nimport { randomBytes } from 'crypto';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport type {\n  AutoRegisterEncryptionKeyOptions,\n  CipherEnvelope,\n  ClientEncryptionOptions,\n  DecryptCipherEnvelopeOptions,\n  DeriveSharedSecretOptions,\n  EncryptCipherEnvelopeOptions,\n  EphemeralKeyPair,\n  EnsureAgentKeyOptions,\n  RegisterEncryptionKeyPayload,\n  RegisterEncryptionKeyResponse,\n  SharedSecretInput,\n} from '../types';\nimport { registerEncryptionKeyResponseSchema } from '../schemas';\nimport { optionalImport } from '../../../utils/dynamic-import';\nimport type {\n  RegistryBrokerClient,\n  GenerateEncryptionKeyPairOptions,\n} from './base-client';\n\ntype FsModule = {\n  existsSync: (path: string) => boolean;\n  readFileSync: (path: string, encoding: BufferEncoding) => string;\n  writeFileSync: (path: string, data: string) => void;\n  appendFileSync: (path: string, data: string) => void;\n};\n\nconst getFs = async (): Promise<FsModule | null> => {\n  const fsModule = await optionalImport<Partial<FsModule>>('node:fs');\n\n  if (\n    fsModule &&\n    typeof fsModule.existsSync === 'function' &&\n    typeof fsModule.readFileSync === 'function' &&\n    typeof fsModule.writeFileSync === 'function' &&\n    typeof fsModule.appendFileSync === 'function'\n  ) {\n    return fsModule as FsModule;\n  }\n\n  return null;\n};\n\nexport interface RegistryBrokerEncryptionApi {\n  registerKey: (\n    payload: RegisterEncryptionKeyPayload,\n  ) => Promise<RegisterEncryptionKeyResponse>;\n  generateEphemeralKeyPair: () => EphemeralKeyPair;\n  deriveSharedSecret: (options: DeriveSharedSecretOptions) => Buffer;\n  encryptCipherEnvelope: (\n    options: EncryptCipherEnvelopeOptions,\n  ) => CipherEnvelope;\n  decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) => string;\n  ensureAgentKey: (\n    options: EnsureAgentKeyOptions,\n  ) => Promise<{ publicKey: string; privateKey?: string }>;\n}\n\nexport async function registerEncryptionKey(\n  client: RegistryBrokerClient,\n  payload: RegisterEncryptionKeyPayload,\n): Promise<RegisterEncryptionKeyResponse> {\n  const raw = await client.requestJson('/encryption/keys', {\n    method: 'POST',\n    headers: { 'content-type': 'application/json' },\n    body: payload,\n  });\n  return client.parseWithSchema(\n    raw,\n    registerEncryptionKeyResponseSchema,\n    'register encryption key response',\n  );\n}\n\nfunction normalizeAutoRegisterIdentity(\n  config: AutoRegisterEncryptionKeyOptions,\n): Pick<\n  RegisterEncryptionKeyPayload,\n  'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n> | null {\n  const identity: Pick<\n    RegisterEncryptionKeyPayload,\n    'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n  > = {};\n  if (config.uaid) {\n    identity.uaid = config.uaid;\n  }\n  if (config.ledgerAccountId) {\n    identity.ledgerAccountId = config.ledgerAccountId;\n    if (config.ledgerNetwork) {\n      identity.ledgerNetwork = config.ledgerNetwork;\n    }\n  }\n  if (config.email) {\n    identity.email = config.email;\n  }\n  if (identity.uaid || identity.ledgerAccountId || identity.email) {\n    return identity;\n  }\n  return null;\n}\n\nfunction derivePublicKeyFromPrivateKey(\n  client: RegistryBrokerClient,\n  privateKey: string,\n): string {\n  const normalized = client.hexToBuffer(privateKey);\n  const publicKey = secp256k1.getPublicKey(normalized, true);\n  return Buffer.from(publicKey).toString('hex');\n}\n\nasync function resolveAutoRegisterKeyMaterial(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (config.publicKey?.trim()) {\n    return { publicKey: config.publicKey.trim() };\n  }\n  let privateKey = config.privateKey?.trim();\n  const envVar = config.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {\n    privateKey = process.env[envVar]?.trim();\n  }\n  if (!privateKey && config.generateIfMissing) {\n    const pair = await client.generateEncryptionKeyPair({\n      keyType: config.keyType ?? 'secp256k1',\n      envVar,\n      envPath: config.envPath,\n      overwrite: config.overwriteEnv,\n    });\n    return { publicKey: pair.publicKey, privateKey: pair.privateKey };\n  }\n  if (privateKey) {\n    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);\n    return { publicKey, privateKey };\n  }\n  return null;\n}\n\nexport async function autoRegisterEncryptionKey(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  const identity = normalizeAutoRegisterIdentity(config);\n  if (!identity) {\n    throw new Error(\n      'Auto-registration requires uaid, ledgerAccountId, or email',\n    );\n  }\n  const material = await resolveAutoRegisterKeyMaterial(client, config);\n  if (!material) {\n    throw new Error(\n      'Unable to resolve encryption public key for auto-registration',\n    );\n  }\n  await registerEncryptionKey(client, {\n    keyType: config.keyType ?? 'secp256k1',\n    publicKey: material.publicKey,\n    ...identity,\n  });\n  return material;\n}\n\nexport async function ensureAgentEncryptionKey(\n  client: RegistryBrokerClient,\n  options: EnsureAgentKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  return autoRegisterEncryptionKey(client, {\n    ...options,\n    uaid: options.uaid,\n    enabled: true,\n  });\n}\n\nexport function createEncryptionApi(\n  client: RegistryBrokerClient,\n): RegistryBrokerEncryptionApi {\n  return {\n    registerKey: (payload: RegisterEncryptionKeyPayload) =>\n      registerEncryptionKey(client, payload),\n    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),\n    deriveSharedSecret: (options: DeriveSharedSecretOptions) =>\n      client.deriveSharedSecret(options),\n    encryptCipherEnvelope: (options: EncryptCipherEnvelopeOptions) =>\n      client.buildCipherEnvelope(options),\n    decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) =>\n      client.openCipherEnvelope(options),\n    ensureAgentKey: (options: EnsureAgentKeyOptions) =>\n      ensureAgentEncryptionKey(client, options),\n  };\n}\n\nexport async function bootstrapEncryptionOptions(\n  client: RegistryBrokerClient,\n  options?: ClientEncryptionOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (!options?.autoRegister || options.autoRegister.enabled === false) {\n    return null;\n  }\n  return autoRegisterEncryptionKey(client, options.autoRegister);\n}\n\nexport async function generateEncryptionKeyPair(\n  client: RegistryBrokerClient,\n  options: GenerateEncryptionKeyPairOptions = {},\n): Promise<{\n  privateKey: string;\n  publicKey: string;\n  envPath?: string;\n  envVar: string;\n}> {\n  client.assertNodeRuntime('generateEncryptionKeyPair');\n\n  const keyType = options.keyType ?? 'secp256k1';\n  if (keyType !== 'secp256k1') {\n    throw new Error('Only secp256k1 key generation is supported currently');\n  }\n\n  const privateKeyBytes = randomBytes(32);\n  const privateKey = Buffer.from(privateKeyBytes).toString('hex');\n  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);\n  const publicKey = Buffer.from(publicKeyBytes).toString('hex');\n\n  const envVar = options.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  const resolvedPath = options.envPath\n    ? path.resolve(options.envPath)\n    : undefined;\n\n  if (resolvedPath) {\n    const fsModule = await getFs();\n\n    if (!fsModule) {\n      throw new Error(\n        'File system module is not available; cannot write encryption key env file',\n      );\n    }\n\n    const envLine = `${envVar}=${privateKey}`;\n    if (fsModule.existsSync(resolvedPath)) {\n      const content = fsModule.readFileSync(resolvedPath, 'utf-8');\n      const lineRegex = new RegExp(`^${envVar}=.*$`, 'm');\n      if (lineRegex.test(content)) {\n        if (!options.overwrite) {\n          throw new Error(\n            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`,\n          );\n        }\n        const updated = content.replace(lineRegex, envLine);\n        fsModule.writeFileSync(resolvedPath, updated);\n      } else {\n        const needsNewline = !content.endsWith('\\n');\n        fsModule.appendFileSync(\n          resolvedPath,\n          `${needsNewline ? '\\n' : ''}${envLine}\\n`,\n        );\n      }\n    } else {\n      fsModule.writeFileSync(resolvedPath, `${envLine}\\n`);\n    }\n  }\n\n  return {\n    privateKey,\n    publicKey,\n    envPath: resolvedPath,\n    envVar,\n  };\n}\n"],"names":[],"mappings":";;;;;;AA+BA,MAAM,QAAQ,YAAsC;AAClD,QAAM,WAAW,MAAM,eAAkC,SAAS;AAElE,MACE,YACA,OAAO,SAAS,eAAe,cAC/B,OAAO,SAAS,iBAAiB,cACjC,OAAO,SAAS,kBAAkB,cAClC,OAAO,SAAS,mBAAmB,YACnC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAiBA,eAAsB,sBACpB,QACA,SACwC;AACxC,QAAM,MAAM,MAAM,OAAO,YAAY,oBAAoB;AAAA,IACvD,QAAQ;AAAA,IACR,SAAS,EAAE,gBAAgB,mBAAA;AAAA,IAC3B,MAAM;AAAA,EAAA,CACP;AACD,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,SAAS,8BACP,QAIO;AACP,QAAM,WAGF,CAAA;AACJ,MAAI,OAAO,MAAM;AACf,aAAS,OAAO,OAAO;AAAA,EACzB;AACA,MAAI,OAAO,iBAAiB;AAC1B,aAAS,kBAAkB,OAAO;AAClC,QAAI,OAAO,eAAe;AACxB,eAAS,gBAAgB,OAAO;AAAA,IAClC;AAAA,EACF;AACA,MAAI,OAAO,OAAO;AAChB,aAAS,QAAQ,OAAO;AAAA,EAC1B;AACA,MAAI,SAAS,QAAQ,SAAS,mBAAmB,SAAS,OAAO;AAC/D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,SAAS,8BACP,QACA,YACQ;AACR,QAAM,aAAa,OAAO,YAAY,UAAU;AAChD,QAAM,YAAY,UAAU,aAAa,YAAY,IAAI;AACzD,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,KAAK;AAC9C;AAEA,eAAe,+BACb,QACA,QAC4D;AAC5D,MAAI,OAAO,WAAW,QAAQ;AAC5B,WAAO,EAAE,WAAW,OAAO,UAAU,OAAK;AAAA,EAC5C;AACA,MAAI,aAAa,OAAO,YAAY,KAAA;AACpC,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI,CAAC,cAAc,UAAU,SAAS,MAAM,MAAM,GAAG,QAAQ;AAC3D,iBAAa,QAAQ,IAAI,MAAM,GAAG,KAAA;AAAA,EACpC;AACA,MAAI,CAAC,cAAc,OAAO,mBAAmB;AAC3C,UAAM,OAAO,MAAM,OAAO,0BAA0B;AAAA,MAClD,SAAS,OAAO,WAAW;AAAA,MAC3B;AAAA,MACA,SAAS,OAAO;AAAA,MAChB,WAAW,OAAO;AAAA,IAAA,CACnB;AACD,WAAO,EAAE,WAAW,KAAK,WAAW,YAAY,KAAK,WAAA;AAAA,EACvD;AACA,MAAI,YAAY;AACd,UAAM,YAAY,8BAA8B,QAAQ,UAAU;AAClE,WAAO,EAAE,WAAW,WAAA;AAAA,EACtB;AACA,SAAO;AACT;AAEA,eAAsB,0BACpB,QACA,QACqD;AACrD,QAAM,WAAW,8BAA8B,MAAM;AACrD,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,WAAW,MAAM,+BAA+B,QAAQ,MAAM;AACpE,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,sBAAsB,QAAQ;AAAA,IAClC,SAAS,OAAO,WAAW;AAAA,IAC3B,WAAW,SAAS;AAAA,IACpB,GAAG;AAAA,EAAA,CACJ;AACD,SAAO;AACT;AAEA,eAAsB,yBACpB,QACA,SACqD;AACrD,SAAO,0BAA0B,QAAQ;AAAA,IACvC,GAAG;AAAA,IACH,MAAM,QAAQ;AAAA,EAEhB,CAAC;AACH;AAEO,SAAS,oBACd,QAC6B;AAC7B,SAAO;AAAA,IACL,aAAa,CAAC,YACZ,sBAAsB,QAAQ,OAAO;AAAA,IACvC,0BAA0B,MAAM,OAAO,uBAAA;AAAA,IACvC,oBAAoB,CAAC,YACnB,OAAO,mBAAmB,OAAO;AAAA,IACnC,uBAAuB,CAAC,YACtB,OAAO,oBAAoB,OAAO;AAAA,IACpC,uBAAuB,CAAC,YACtB,OAAO,mBAAmB,OAAO;AAAA,IACnC,gBAAgB,CAAC,YACf,yBAAyB,QAAQ,OAAO;AAAA,EAAA;AAE9C;AAEA,eAAsB,2BACpB,QACA,SAC4D;AAC5D,MAAI,CAAC,SAAS,gBAAgB,QAAQ,aAAa,YAAY,OAAO;AACpE,WAAO;AAAA,EACT;AACA,SAAO,0BAA0B,QAAQ,QAAQ,YAAY;AAC/D;AAEA,eAAsB,0BACpB,QACA,UAA4C,IAM3C;AACD,SAAO,kBAAkB,2BAA2B;AAEpD,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,YAAY,aAAa;AAC3B,UAAM,IAAI,MAAM,sDAAsD;AAAA,EACxE;AAEA,QAAM,kBAAkB,YAAY,EAAE;AACtC,QAAM,aAAa,OAAO,KAAK,eAAe,EAAE,SAAS,KAAK;AAC9D,QAAM,iBAAiB,UAAU,aAAa,iBAAiB,IAAI;AACnE,QAAM,YAAY,OAAO,KAAK,cAAc,EAAE,SAAS,KAAK;AAE5D,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,eAAe,QAAQ,UACzB,KAAK,QAAQ,QAAQ,OAAO,IAC5B;AAEJ,MAAI,cAAc;AAChB,UAAM,WAAW,MAAM,MAAA;AAEvB,QAAI,CAAC,UAAU;AACb,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAEA,UAAM,UAAU,GAAG,MAAM,IAAI,UAAU;AACvC,QAAI,SAAS,WAAW,YAAY,GAAG;AACrC,YAAM,UAAU,SAAS,aAAa,cAAc,OAAO;AAC3D,YAAM,YAAY,IAAI,OAAO,IAAI,MAAM,QAAQ,GAAG;AAClD,UAAI,UAAU,KAAK,OAAO,GAAG;AAC3B,YAAI,CAAC,QAAQ,WAAW;AACtB,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,sBAAsB,YAAY;AAAA,UAAA;AAAA,QAE/C;AACA,cAAM,UAAU,QAAQ,QAAQ,WAAW,OAAO;AAClD,iBAAS,cAAc,cAAc,OAAO;AAAA,MAC9C,OAAO;AACL,cAAM,eAAe,CAAC,QAAQ,SAAS,IAAI;AAC3C,iBAAS;AAAA,UACP;AAAA,UACA,GAAG,eAAe,OAAO,EAAE,GAAG,OAAO;AAAA;AAAA,QAAA;AAAA,MAEzC;AAAA,IACF,OAAO;AACL,eAAS,cAAc,cAAc,GAAG,OAAO;AAAA,CAAI;AAAA,IACrD;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"standards-sdk.es175.js","sources":["../../src/services/registry-broker/client/chat-history.ts"],"sourcesContent":["import { Buffer } from 'buffer';\nimport type {\n  ChatHistoryEntry,\n  ChatHistoryFetchOptions,\n  ChatHistorySnapshotResponse,\n  ChatHistorySnapshotWithDecryptedEntries,\n  JsonValue,\n  RecipientIdentity,\n} from '../types';\nimport { chatHistorySnapshotResponseSchema } from '../schemas';\nimport type { RegistryBrokerClient } from './base-client';\n\nexport interface ConversationContextInput {\n  sessionId: string;\n  sharedSecret: Uint8Array | Buffer;\n  identity?: RecipientIdentity;\n}\n\nexport interface ConversationContextState {\n  sessionId: string;\n  sharedSecret: Buffer;\n  identity?: RecipientIdentity;\n}\n\nfunction identitiesMatch(\n  a?: RecipientIdentity,\n  b?: RecipientIdentity,\n): boolean {\n  if (!a && !b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  if (a.uaid && b.uaid && a.uaid.toLowerCase() === b.uaid.toLowerCase()) {\n    return true;\n  }\n  if (\n    a.ledgerAccountId &&\n    b.ledgerAccountId &&\n    a.ledgerAccountId.toLowerCase() === b.ledgerAccountId.toLowerCase()\n  ) {\n    return true;\n  }\n  if (a.userId && b.userId && a.userId === b.userId) {\n    return true;\n  }\n  if (a.email && b.email && a.email.toLowerCase() === b.email.toLowerCase()) {\n    return true;\n  }\n  return false;\n}\n\nexport async function fetchHistorySnapshot(\n  conversationContexts: Map<string, ConversationContextState[]>,\n  client: RegistryBrokerClient,\n  sessionId: string,\n  options?: ChatHistoryFetchOptions,\n): Promise<ChatHistorySnapshotWithDecryptedEntries> {\n  if (!sessionId || sessionId.trim().length === 0) {\n    throw new Error('sessionId is required to fetch chat history');\n  }\n  const raw = await client.requestJson<JsonValue>(\n    `/chat/session/${encodeURIComponent(sessionId)}/history`,\n    {\n      method: 'GET',\n    },\n  );\n  const snapshot = client.parseWithSchema(\n    raw,\n    chatHistorySnapshotResponseSchema,\n    'chat history snapshot response',\n  );\n  return attachDecryptedHistory(\n    conversationContexts,\n    client,\n    sessionId,\n    snapshot,\n    options,\n  );\n}\n\nexport function attachDecryptedHistory(\n  conversationContexts: Map<string, ConversationContextState[]>,\n  client: RegistryBrokerClient,\n  sessionId: string,\n  snapshot: ChatHistorySnapshotResponse,\n  options?: ChatHistoryFetchOptions,\n): ChatHistorySnapshotWithDecryptedEntries {\n  const shouldDecrypt =\n    options?.decrypt !== undefined\n      ? options.decrypt\n      : client.encryptionOptions?.autoDecryptHistory === true;\n  if (!shouldDecrypt) {\n    return snapshot;\n  }\n  const requiresContext = snapshot.history.some(entry =>\n    Boolean(entry.cipherEnvelope),\n  );\n  if (!requiresContext) {\n    return {\n      ...snapshot,\n      decryptedHistory: snapshot.history.map(entry => ({\n        entry,\n        plaintext: entry.content,\n      })),\n    };\n  }\n  const context = resolveDecryptionContext(\n    conversationContexts,\n    client,\n    sessionId,\n    options,\n  );\n  if (!context) {\n    throw new Error(\n      'Unable to decrypt chat history: encryption context unavailable',\n    );\n  }\n  const decryptedHistory = snapshot.history.map(entry => ({\n    entry,\n    plaintext: decryptHistoryEntryFromContext(client, entry, context),\n  }));\n  return { ...snapshot, decryptedHistory };\n}\n\nexport function registerConversationContextForEncryption(\n  conversationContexts: Map<string, ConversationContextState[]>,\n  context: ConversationContextInput,\n): void {\n  const normalized: ConversationContextState = {\n    sessionId: context.sessionId,\n    sharedSecret: Buffer.from(context.sharedSecret),\n    identity: context.identity ? { ...context.identity } : undefined,\n  };\n  const entries = conversationContexts.get(context.sessionId) ?? [];\n  const existingIndex = entries.findIndex(existing =>\n    identitiesMatch(existing.identity, normalized.identity),\n  );\n  if (existingIndex >= 0) {\n    entries[existingIndex] = normalized;\n  } else {\n    entries.push(normalized);\n  }\n  conversationContexts.set(context.sessionId, entries);\n}\n\nexport function resolveDecryptionContext(\n  conversationContexts: Map<string, ConversationContextState[]>,\n  client: RegistryBrokerClient,\n  sessionId: string,\n  options?: ChatHistoryFetchOptions,\n): ConversationContextState | null {\n  if (options?.sharedSecret) {\n    return {\n      sessionId,\n      sharedSecret: client.normalizeSharedSecret(options.sharedSecret),\n      identity: options.identity,\n    };\n  }\n  const contexts = conversationContexts.get(sessionId);\n  if (!contexts || contexts.length === 0) {\n    return null;\n  }\n  if (options?.identity) {\n    const match = contexts.find(context =>\n      identitiesMatch(context.identity, options.identity),\n    );\n    if (match) {\n      return match;\n    }\n  }\n  return contexts[0];\n}\n\nexport function decryptHistoryEntryFromContext(\n  client: RegistryBrokerClient,\n  entry: ChatHistoryEntry,\n  context: ConversationContextState,\n): string | null {\n  const envelope = entry.cipherEnvelope;\n  if (!envelope) {\n    return entry.content;\n  }\n  const secret = Buffer.from(context.sharedSecret);\n  try {\n    return client.encryption.decryptCipherEnvelope({\n      envelope,\n      sharedSecret: secret,\n    });\n  } catch (_error) {\n    return null;\n  }\n}\n"],"names":[],"mappings":"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"}