@hashgraphonline/standards-sdk 0.1.158 → 0.1.160

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

@@ -1,481 +1,116 @@
-import { Logger } from "./standards-sdk.es111.js";
-import { HederaMirrorNode } from "./standards-sdk.es132.js";
-import { HRLResolver } from "./standards-sdk.es115.js";
-import { hash } from "./standards-sdk.es125.js";
-import { hcs26DiscoveryMetadataSchema, hcs26DiscoveryMetadataPatchSchema, hcs26DiscoveryRegisterSchema, hcs26DiscoveryRegisterLegacySchema, hcs26DiscoveryDeleteSchema, hcs26DiscoveryUpdateSchema, hcs26DiscoveryUpdateLegacySchema, hcs26VersionRegisterSchema, hcs26VersionRegisterLegacySchema, hcs26VersionUpdateSchema, hcs26VersionDeleteSchema, hcs26SkillManifestSchema } from "./standards-sdk.es105.js";
-function parseSemver(versionRaw) {
-  const trimmed = versionRaw.trim().replace(/^v/i, "");
-  const match = trimmed.match(
-    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
-  );
-  if (!match) {
-    return null;
-  }
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  const patch = Number(match[3]);
-  if (![major, minor, patch].every(Number.isFinite)) {
-    return null;
-  }
-  const prereleaseRaw = match[4];
-  const prerelease = prereleaseRaw ? prereleaseRaw.split(".").map((part) => {
-    if (/^(0|[1-9]\d*)$/.test(part)) {
-      return Number(part);
-    }
-    return part;
-  }) : [];
-  return { major, minor, patch, prerelease };
-}
-function compareSemver(a, b) {
-  if (a.major !== b.major) return a.major - b.major;
-  if (a.minor !== b.minor) return a.minor - b.minor;
-  if (a.patch !== b.patch) return a.patch - b.patch;
-  const aHasPre = a.prerelease.length > 0;
-  const bHasPre = b.prerelease.length > 0;
-  if (!aHasPre && bHasPre) return 1;
-  if (aHasPre && !bHasPre) return -1;
-  if (!aHasPre && !bHasPre) return 0;
-  const len = Math.max(a.prerelease.length, b.prerelease.length);
-  for (let index = 0; index < len; index += 1) {
-    const aId = a.prerelease[index];
-    const bId = b.prerelease[index];
-    if (aId === void 0 && bId !== void 0) return -1;
-    if (aId !== void 0 && bId === void 0) return 1;
-    if (aId === bId) continue;
-    if (typeof aId === "number" && typeof bId === "number") {
-      return aId - bId;
-    }
-    if (typeof aId === "number" && typeof bId === "string") {
-      return -1;
-    }
-    if (typeof aId === "string" && typeof bId === "number") {
-      return 1;
-    }
-    if (typeof aId === "string" && typeof bId === "string") {
-      return aId < bId ? -1 : 1;
-    }
-  }
-  return 0;
-}
-function isActiveStatus(status) {
-  return !status || status === "active";
-}
-function normalizeUidString(value) {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function resolveSequenceNumber(primary, fallback) {
-  if (typeof primary === "number") {
-    return primary;
-  }
-  if (typeof fallback === "number") {
-    return fallback;
-  }
-  return null;
-}
-function parseSequenceFromUid(uid) {
-  if (!/^\d+$/.test(uid)) {
-    return null;
-  }
-  const parsed = Number(uid);
-  return Number.isSafeInteger(parsed) ? parsed : null;
-}
-function ensureNonEmptyString(value, field) {
-  if (typeof value !== "string") {
-    throw new Error(`Expected ${field} to be a string`);
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error(`Expected ${field} to be a non-empty string`);
-  }
-  return trimmed;
-}
-function mergeDiscoveryMetadata(base, update) {
-  if (!update) {
-    return base;
-  }
-  return { ...base, ...update };
-}
-function normalizeDiscoveryRegister(input, messageSequenceNumber) {
-  const seq = typeof input.sequence_number === "number" ? input.sequence_number : typeof messageSequenceNumber === "number" ? messageSequenceNumber : void 0;
-  if ("t_id" in input) {
-    return {
-      p: "hcs-26",
-      op: "register",
-      t_id: ensureNonEmptyString(input.t_id, "t_id"),
-      account_id: ensureNonEmptyString(input.account_id, "account_id"),
-      metadata: input.metadata,
-      ...input.m ? { m: input.m } : {},
-      ...typeof seq === "number" ? { sequence_number: seq } : {}
-    };
-  }
-  return {
-    p: "hcs-26",
-    op: "register",
-    t_id: ensureNonEmptyString(input.version_registry, "version_registry"),
-    account_id: ensureNonEmptyString(input.publisher, "publisher"),
-    metadata: input.metadata,
-    ...input.m ? { m: input.m } : {},
-    ...typeof seq === "number" ? { sequence_number: seq } : {}
-  };
-}
-class Hcs26SkillRegistryResolver {
-  constructor(deps) {
-    this.network = deps.network;
-    this.logger = deps.logger ?? Logger.getInstance({
-      module: "HCS26Resolver",
-      level: "info"
+import { Client } from "@hashgraph/sdk";
+import { Logger } from "./standards-sdk.es116.js";
+import { createNodeOperatorContext } from "./standards-sdk.es151.js";
+import { buildHcs18CreateDiscoveryTopicTx, buildHcs18AnnounceMessage, buildHcs18SubmitDiscoveryMessageTx, buildHcs18ProposeMessage, buildHcs18RespondMessage, buildHcs18CompleteMessage, buildHcs18WithdrawMessage } from "./standards-sdk.es108.js";
+import { HCS18BaseClient } from "./standards-sdk.es109.js";
+class HCS18Client extends HCS18BaseClient {
+  constructor(config) {
+    super({
+      network: config.network,
+      logger: Logger.getInstance({
+        level: config.logLevel || "info",
+        module: "HCS-18",
+        silent: config.silent
+      })
     });
-    this.mirrorNode = new HederaMirrorNode(
-      deps.network,
-      this.logger,
-      deps.mirrorNode
-    );
-    this.hrlResolver = new HRLResolver("warn");
-  }
-  async resolveDiscoveryMetadataHrl(metadataHrl, mode) {
-    const resolved = await this.hrlResolver.resolve(metadataHrl, {
+    this.operatorCtx = createNodeOperatorContext({
       network: this.network,
-      returnRaw: true
+      operatorId: config.operatorId,
+      operatorKey: config.operatorKey,
+      mirrorNode: this.mirrorNode,
+      logger: this.logger,
+      client: Client.forName(this.network)
     });
-    const bytes = resolved.content instanceof ArrayBuffer ? Buffer.from(resolved.content) : Buffer.from(String(resolved.content), "utf8");
-    let raw;
-    try {
-      raw = JSON.parse(bytes.toString("utf8"));
-    } catch {
-      throw new Error("Discovery metadata HRL content is not valid JSON");
-    }
-    const schema = mode === "full" ? hcs26DiscoveryMetadataSchema : hcs26DiscoveryMetadataPatchSchema;
-    const parsed = schema.safeParse(raw);
-    if (!parsed.success) {
-      throw new Error(`Invalid discovery metadata: ${parsed.error.message}`);
-    }
-    return this.normalizeDiscoveryMetadataObject(
-      parsed.data
-    );
-  }
-  normalizeDiscoveryMetadataObject(metadata) {
-    if (typeof metadata.icon !== "string" || metadata.icon.trim().length === 0) {
-      const iconLegacy = metadata.icon_hcs1;
-      if (typeof iconLegacy === "string" && iconLegacy.trim().length > 0) {
-        return { ...metadata, icon: iconLegacy };
-      }
-    }
-    return metadata;
+    this.client = this.operatorCtx.client;
   }
-  async resolveDiscoveryMetadataUri(metadataUri, mode) {
-    const trimmed = metadataUri.trim();
-    if (trimmed.startsWith("hcs://1/")) {
-      return this.resolveDiscoveryMetadataHrl(trimmed, mode);
-    }
-    throw new Error(`Unsupported discovery metadata URI: ${trimmed}`);
-  }
-  resolveDiscoveryMetadataObject(params) {
-    if (typeof params.metadata === "string") {
-      return this.resolveDiscoveryMetadataUri(params.metadata, params.mode);
-    }
-    const schema = params.mode === "full" ? hcs26DiscoveryMetadataSchema : hcs26DiscoveryMetadataPatchSchema;
-    const parsed = schema.safeParse(params.metadata);
-    if (!parsed.success) {
-      throw new Error(`Invalid discovery metadata: ${parsed.error.message}`);
-    }
-    return Promise.resolve(
-      this.normalizeDiscoveryMetadataObject(
-        parsed.data
-      )
-    );
+  async ensureInitialized() {
+    await this.operatorCtx.ensureInitialized();
   }
-  async getDiscoveryRegister(params) {
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.directoryTopicId,
-      {
-        sequenceNumber: `eq:${params.skillUid}`,
-        limit: 5,
-        order: "asc"
-      }
-    );
-    for (const message of messages) {
-      const parsedNew = hcs26DiscoveryRegisterSchema.safeParse(message);
-      const parsedLegacy = parsedNew.success ? null : hcs26DiscoveryRegisterLegacySchema.safeParse(message);
-      const parsed = parsedNew.success ? parsedNew : parsedLegacy && parsedLegacy.success ? parsedLegacy : null;
-      if (!parsed) {
-        continue;
-      }
-      const normalized = normalizeDiscoveryRegister(
-        parsed.data,
-        message.sequence_number
-      );
-      const seq = normalized.sequence_number;
-      if (typeof seq === "number" && seq === params.skillUid) {
-        const metadata = await this.resolveDiscoveryMetadataObject({
-          metadata: normalized.metadata,
-          mode: "full"
-        });
-        return { ...normalized, metadata };
-      }
-    }
-    return null;
-  }
-  async resolveDiscoveryRecord(params) {
-    const register = await this.getDiscoveryRegister({
-      directoryTopicId: params.directoryTopicId,
-      skillUid: params.skillUid
+  async createDiscoveryTopic(options) {
+    await this.ensureInitialized();
+    const ttl = options?.ttlSeconds;
+    let operatorPublicKey;
+    try {
+      operatorPublicKey = this.operatorCtx.operatorKey.publicKey;
+    } catch {
+      operatorPublicKey = void 0;
+    }
+    const tx = buildHcs18CreateDiscoveryTopicTx({
+      ttlSeconds: ttl,
+      adminKey: options?.adminKey,
+      submitKey: options?.submitKey,
+      operatorPublicKey,
+      memoOverride: options?.memoOverride
     });
-    if (!register) {
-      return null;
-    }
-    const scanLimit = typeof params.scanLimit === "number" && params.scanLimit > 0 ? Math.min(5e3, Math.floor(params.scanLimit)) : 1e3;
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.directoryTopicId,
-      {
-        limit: scanLimit,
-        order: "asc"
-      }
-    );
-    const uid = String(params.skillUid);
-    const registerSequence = resolveSequenceNumber(
-      register.sequence_number,
-      params.skillUid
-    );
-    let current = register;
-    for (const message of messages) {
-      const messageSequence = resolveSequenceNumber(
-        void 0,
-        message.sequence_number
-      );
-      const deleteParsed = hcs26DiscoveryDeleteSchema.safeParse(message);
-      if (deleteParsed.success && deleteParsed.data.uid === uid) {
-        const deleteSequence = resolveSequenceNumber(
-          deleteParsed.data.sequence_number,
-          messageSequence
-        );
-        if (registerSequence !== null && deleteSequence !== null && deleteSequence <= registerSequence) {
-          continue;
-        }
-        return null;
-      }
-      const updateParsedNew = hcs26DiscoveryUpdateSchema.safeParse(message);
-      const updateParsedLegacy = updateParsedNew.success ? null : hcs26DiscoveryUpdateLegacySchema.safeParse(message);
-      const updateParsed = updateParsedNew.success ? updateParsedNew : updateParsedLegacy && updateParsedLegacy.success ? updateParsedLegacy : null;
-      if (!updateParsed || updateParsed.data.uid !== uid) {
-        continue;
-      }
-      const updateSequence = resolveSequenceNumber(
-        updateParsed.data.sequence_number,
-        messageSequence
-      );
-      if (registerSequence !== null && updateSequence !== null && updateSequence <= registerSequence) {
-        continue;
-      }
-      const nextAccountId = "account_id" in updateParsed.data ? normalizeUidString(updateParsed.data.account_id) : normalizeUidString(updateParsed.data.publisher);
-      const nextMetadataRaw = updateParsed.data.metadata;
-      const nextMetadata = nextMetadataRaw !== void 0 ? await this.resolveDiscoveryMetadataObject({
-        metadata: nextMetadataRaw,
-        mode: "patch"
-      }) : void 0;
-      current = {
-        ...current,
-        ...nextAccountId ? { account_id: nextAccountId } : {},
-        metadata: mergeDiscoveryMetadata(current.metadata, nextMetadata)
-      };
-    }
-    return current;
-  }
-  async listVersionRegisters(params) {
-    const limit = typeof params.limit === "number" && params.limit > 0 ? Math.min(1e3, params.limit) : 500;
-    const messages = await this.mirrorNode.getTopicMessages(
-      params.versionRegistryTopicId,
-      {
-        limit,
-        order: "desc"
-      }
-    );
-    const registersByUid = /* @__PURE__ */ new Map();
-    const updatesByUid = /* @__PURE__ */ new Map();
-    const deletedByUid = /* @__PURE__ */ new Map();
-    for (const message of messages) {
-      const parsedNew = hcs26VersionRegisterSchema.safeParse(message);
-      const parsedLegacy = parsedNew.success ? null : hcs26VersionRegisterLegacySchema.safeParse(message);
-      const registerParsed = parsedNew.success ? parsedNew : parsedLegacy && parsedLegacy.success ? parsedLegacy : null;
-      if (registerParsed) {
-        if (registerParsed.data.skill_uid !== params.skillUid) {
-          continue;
-        }
-        const uid = typeof registerParsed.data.sequence_number === "number" ? String(registerParsed.data.sequence_number) : typeof message.sequence_number === "number" ? String(message.sequence_number) : null;
-        if (uid) {
-          const registerSequence = resolveSequenceNumber(
-            registerParsed.data.sequence_number,
-            message.sequence_number
-          );
-          registersByUid.set(uid, {
-            register: registerParsed.data,
-            sequenceNumber: registerSequence
-          });
-        }
-        continue;
-      }
-      const updateParsed = hcs26VersionUpdateSchema.safeParse(message);
-      if (updateParsed.success) {
-        const uid = updateParsed.data.uid.trim();
-        const list = updatesByUid.get(uid) ?? [];
-        list.push({
-          update: updateParsed.data,
-          sequenceNumber: resolveSequenceNumber(
-            updateParsed.data.sequence_number,
-            message.sequence_number
-          )
-        });
-        updatesByUid.set(uid, list);
-        continue;
-      }
-      const deleteParsed = hcs26VersionDeleteSchema.safeParse(message);
-      if (deleteParsed.success) {
-        const uid = deleteParsed.data.uid.trim();
-        const list = deletedByUid.get(uid) ?? [];
-        const sequenceNumber = resolveSequenceNumber(
-          deleteParsed.data.sequence_number,
-          message.sequence_number
-        );
-        if (sequenceNumber !== null) {
-          list.push(sequenceNumber);
-          deletedByUid.set(uid, list);
-        }
-      }
-    }
-    const entries = [];
-    for (const [uid, registerState] of registersByUid.entries()) {
-      const registerSequence = registerState.sequenceNumber ?? parseSequenceFromUid(uid);
-      const deleteSequences = deletedByUid.get(uid) ?? [];
-      const hasDeleteAfterRegister = deleteSequences.some(
-        (sequence) => registerSequence === null ? true : sequence > registerSequence
-      );
-      if (hasDeleteAfterRegister) {
-        continue;
-      }
-      const updates = updatesByUid.get(uid);
-      if (!updates || updates.length === 0) {
-        entries.push(registerState.register);
-        continue;
-      }
-      const sorted = [...updates].filter(
-        (update) => registerSequence === null ? true : update.sequenceNumber !== null && update.sequenceNumber > registerSequence
-      ).sort((a, b) => {
-        const aSeq = a.sequenceNumber ?? 0;
-        const bSeq = b.sequenceNumber ?? 0;
-        return aSeq - bSeq;
-      });
-      if (sorted.length === 0) {
-        entries.push(registerState.register);
-        continue;
-      }
-      const final = sorted.reduce((acc, updateState) => {
-        if (updateState.update.status) {
-          return { ...acc, status: updateState.update.status };
-        }
-        return acc;
-      }, registerState.register);
-      entries.push(final);
-    }
-    return entries;
-  }
-  async getLatestVersionRegister(params) {
-    const entries = await this.listVersionRegisters({
-      versionRegistryTopicId: params.versionRegistryTopicId,
-      skillUid: params.skillUid,
-      limit: 100
+    const resp = await tx.execute(this.client);
+    const receipt = await resp.getReceipt(this.client);
+    const topicId = receipt.topicId?.toString();
+    if (!topicId) {
+      throw new Error("Failed to create discovery topic");
+    }
+    return { topicId, receipt };
+  }
+  async announce(params) {
+    await this.ensureInitialized();
+    const message = buildHcs18AnnounceMessage(params.data);
+    const tx = buildHcs18SubmitDiscoveryMessageTx({
+      topicId: params.discoveryTopicId,
+      message,
+      transactionMemo: params.memo
     });
-    const active = entries.filter((entry) => isActiveStatus(entry.status));
-    if (active.length === 0) {
-      return null;
-    }
-    let best = active[0];
-    let bestParsed = parseSemver(best.version);
-    for (let index = 1; index < active.length; index += 1) {
-      const candidate = active[index];
-      const candidateParsed = parseSemver(candidate.version);
-      if (!bestParsed && candidateParsed) {
-        best = candidate;
-        bestParsed = candidateParsed;
-        continue;
-      }
-      if (bestParsed && candidateParsed) {
-        const cmp = compareSemver(candidateParsed, bestParsed);
-        if (cmp > 0) {
-          best = candidate;
-          bestParsed = candidateParsed;
-          continue;
-        }
-        if (cmp === 0) {
-          const bestSeq = typeof best.sequence_number === "number" ? best.sequence_number : 0;
-          const candSeq = typeof candidate.sequence_number === "number" ? candidate.sequence_number : 0;
-          if (candSeq > bestSeq) {
-            best = candidate;
-            bestParsed = candidateParsed;
-          }
-        }
-      }
-    }
-    return best;
-  }
-  async resolveManifest(params) {
-    const manifestHrl = typeof params.manifestHrl === "string" && params.manifestHrl.trim().length > 0 ? params.manifestHrl.trim() : typeof params.manifestTopicId === "string" && params.manifestTopicId.trim().length > 0 ? `hcs://1/${params.manifestTopicId.trim()}` : null;
-    if (!manifestHrl) {
-      throw new Error("Manifest HRL or topic id is required");
-    }
-    const resolved = await this.hrlResolver.resolve(manifestHrl, {
-      network: this.network,
-      returnRaw: true
+    const resp = await tx.execute(this.client);
+    const receipt = await resp.getReceipt(this.client);
+    const seq = receipt.topicSequenceNumber.toNumber();
+    return { receipt, sequenceNumber: seq };
+  }
+  async propose(params) {
+    await this.ensureInitialized();
+    const message = buildHcs18ProposeMessage(params.data);
+    const tx = buildHcs18SubmitDiscoveryMessageTx({
+      topicId: params.discoveryTopicId,
+      message,
+      transactionMemo: params.memo
     });
-    const contentType = resolved.contentType ?? "";
-    if (!contentType.toLowerCase().startsWith("application/json")) {
-      throw new Error(
-        `Expected application/json for manifest, got ${resolved.contentType ?? "unknown"}`
-      );
-    }
-    const bytes = resolved.content instanceof ArrayBuffer ? Buffer.from(resolved.content) : Buffer.from(String(resolved.content), "utf8");
-    const sha256Hex = await hash(bytes, "sha256");
-    let raw;
-    try {
-      raw = JSON.parse(bytes.toString("utf8"));
-    } catch {
-      throw new Error("Manifest content is not valid JSON");
-    }
-    const parsed = hcs26SkillManifestSchema.safeParse(raw);
-    if (!parsed.success) {
-      throw new Error(`Invalid HCS-26 manifest: ${parsed.error.message}`);
-    }
-    const hasSkillMd = parsed.data.files.some((file) => file.path === "SKILL.md");
-    if (!hasSkillMd) {
-      throw new Error(
-        'HCS-26 manifest must include SKILL.md at path "SKILL.md"'
-      );
-    }
-    return { manifest: parsed.data, raw, sha256Hex };
-  }
-  async verifyVersionRegisterMatchesManifest(params) {
-    const checksumRaw = params.versionRegister.checksum;
-    if (!checksumRaw) {
-      this.logger.warn(
-        "HCS-26 version register is missing checksum; skipping manifest verification."
-      );
-      return;
-    }
-    const checksum = checksumRaw.trim();
-    if (!checksum.startsWith("sha256:")) {
-      throw new Error(`Unsupported checksum: ${checksum}`);
-    }
-    const expectedHex = checksum.slice("sha256:".length);
-    if (params.manifestSha256Hex !== expectedHex) {
-      throw new Error(
-        `Manifest checksum mismatch (expected ${expectedHex}, got ${params.manifestSha256Hex})`
-      );
-    }
+    const resp = await tx.execute(this.client);
+    const receipt = await resp.getReceipt(this.client);
+    const seq = receipt.topicSequenceNumber.toNumber();
+    return { receipt, sequenceNumber: seq };
+  }
+  async respond(params) {
+    await this.ensureInitialized();
+    const message = buildHcs18RespondMessage(params.data);
+    const tx = buildHcs18SubmitDiscoveryMessageTx({
+      topicId: params.discoveryTopicId,
+      message,
+      transactionMemo: params.memo
+    });
+    const resp = await tx.execute(this.client);
+    return await resp.getReceipt(this.client);
+  }
+  async complete(params) {
+    await this.ensureInitialized();
+    const message = buildHcs18CompleteMessage(params.data);
+    const tx = buildHcs18SubmitDiscoveryMessageTx({
+      topicId: params.discoveryTopicId,
+      message,
+      transactionMemo: params.memo
+    });
+    const resp = await tx.execute(this.client);
+    return await resp.getReceipt(this.client);
+  }
+  async withdraw(params) {
+    await this.ensureInitialized();
+    const message = buildHcs18WithdrawMessage(params.data);
+    const tx = buildHcs18SubmitDiscoveryMessageTx({
+      topicId: params.discoveryTopicId,
+      message,
+      transactionMemo: params.memo
+    });
+    const resp = await tx.execute(this.client);
+    return await resp.getReceipt(this.client);
   }
 }
 export {
-  Hcs26SkillRegistryResolver
+  HCS18Client
 };
 //# sourceMappingURL=standards-sdk.es106.js.map