@hashgraphonline/standards-sdk 0.1.167 → 0.1.169

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

@@ -1,185 +1,481 @@
-let loggerFactory = null;
-function normalizeErrorData(error) {
-  const normalizedData = {
-    name: error.name,
-    message: error.message
-  };
-  if (error.stack) {
-    normalizedData.stack = error.stack;
+import { Logger } from "./standards-sdk.es123.js";
+import { HederaMirrorNode } from "./standards-sdk.es144.js";
+import { HRLResolver } from "./standards-sdk.es127.js";
+import { hash } from "./standards-sdk.es137.js";
+import { hcs26DiscoveryMetadataSchema, hcs26DiscoveryMetadataPatchSchema, hcs26DiscoveryRegisterSchema, hcs26DiscoveryRegisterLegacySchema, hcs26DiscoveryDeleteSchema, hcs26DiscoveryUpdateSchema, hcs26DiscoveryUpdateLegacySchema, hcs26VersionRegisterSchema, hcs26VersionRegisterLegacySchema, hcs26VersionUpdateSchema, hcs26VersionDeleteSchema, hcs26SkillManifestSchema } from "./standards-sdk.es117.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;
   }
-  for (const [key, value] of Object.entries(error)) {
-    normalizedData[key] = value;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (![major, minor, patch].every(Number.isFinite)) {
+    return null;
   }
-  return normalizedData;
+  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 serializeLogData(data) {
-  try {
-    return JSON.stringify(
-      data,
-      (_key, value) => {
-        if (value instanceof Error) {
-          return normalizeErrorData(value);
-        }
-        if (typeof value === "bigint") {
-          return value.toString();
-        }
-        if (value instanceof Map) {
-          return Object.fromEntries(value);
-        }
-        if (value instanceof Set) {
-          return Array.from(value);
-        }
-        if (value instanceof Uint8Array) {
-          return Array.from(value);
-        }
-        return value;
-      },
-      2
-    );
-  } catch {
-    return String(data);
+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 setLoggerFactory(factory) {
-  loggerFactory = factory;
-  Logger.clearInstances();
+function isActiveStatus(status) {
+  return !status || status === "active";
 }
-const _Logger = class _Logger {
-  constructor(options = {}) {
-    if (loggerFactory) {
-      return loggerFactory(options);
-    }
-    const globalDisable = typeof process !== "undefined" && process.env?.DISABLE_LOGS === "true";
-    this.silent = options.silent || globalDisable;
-    this.level = this.silent ? "silent" : options.level || "info";
-    this.moduleContext = options.module || "app";
-    this.prettyPrint = !this.silent && options.prettyPrint !== false;
+function normalizeUidString(value) {
+  if (typeof value !== "string") {
+    return null;
   }
-  static getInstance(options = {}) {
-    const moduleKey = options.module || "default";
-    const globalDisable = typeof process !== "undefined" && process.env?.DISABLE_LOGS === "true";
-    if (globalDisable && _Logger.instances.has(moduleKey)) {
-      const existingLogger = _Logger.instances.get(moduleKey);
-      if (existingLogger.getLevel() !== "silent") {
-        _Logger.instances.delete(moduleKey);
-      }
-    }
-    if (!_Logger.instances.has(moduleKey)) {
-      const logger = loggerFactory ? loggerFactory(options) : new _Logger(options);
-      _Logger.instances.set(moduleKey, logger);
-    }
-    return _Logger.instances.get(moduleKey);
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function resolveSequenceNumber(primary, fallback) {
+  if (typeof primary === "number") {
+    return primary;
   }
-  setLogLevel(level) {
-    this.level = level;
+  if (typeof fallback === "number") {
+    return fallback;
   }
-  getLevel() {
-    return this.level;
+  return null;
+}
+function parseSequenceFromUid(uid) {
+  if (!/^\d+$/.test(uid)) {
+    return null;
   }
-  setSilent(silent) {
-    this.silent = silent;
-    if (silent) {
-      this.level = "silent";
-    }
+  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`);
   }
-  setModule(module) {
-    this.moduleContext = module;
+  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;
   }
-  formatArgs(args) {
-    if (args.length === 0) {
-      return { msg: "" };
+  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"
+    });
+    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, {
+      network: this.network,
+      returnRaw: true
+    });
+    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");
     }
-    if (args.length === 1) {
-      if (typeof args[0] === "string") {
-        return { msg: args[0] };
-      }
-      return { msg: "", data: args[0] };
+    const schema = mode === "full" ? hcs26DiscoveryMetadataSchema : hcs26DiscoveryMetadataPatchSchema;
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`Invalid discovery metadata: ${parsed.error.message}`);
     }
-    const stringArgs = [];
-    const objectArgs = [];
-    args.forEach((arg) => {
-      if (typeof arg === "string" || typeof arg === "number" || typeof arg === "boolean") {
-        stringArgs.push(String(arg));
-      } else {
-        objectArgs.push(arg);
+    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 };
       }
-    });
-    const msg = stringArgs.join(" ");
-    return objectArgs.length > 0 ? { msg, data: objectArgs } : { msg };
+    }
+    return metadata;
   }
-  shouldLog(level) {
-    if (this.silent || this.level === "silent") {
-      return false;
+  async resolveDiscoveryMetadataUri(metadataUri, mode) {
+    const trimmed = metadataUri.trim();
+    if (trimmed.startsWith("hcs://1/")) {
+      return this.resolveDiscoveryMetadataHrl(trimmed, mode);
     }
-    const levels = ["trace", "debug", "info", "warn", "error", "silent"];
-    const currentLevelIndex = levels.indexOf(this.level);
-    const targetLevelIndex = levels.indexOf(level);
-    return targetLevelIndex >= currentLevelIndex;
+    throw new Error(`Unsupported discovery metadata URI: ${trimmed}`);
   }
-  getConsoleMethod(level) {
-    if (level === "error") {
-      return console.error;
+  resolveDiscoveryMetadataObject(params) {
+    if (typeof params.metadata === "string") {
+      return this.resolveDiscoveryMetadataUri(params.metadata, params.mode);
     }
-    if (level === "warn") {
-      return console.warn;
+    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}`);
     }
-    if (level === "debug") {
-      return console.debug;
+    return Promise.resolve(
+      this.normalizeDiscoveryMetadataObject(
+        parsed.data
+      )
+    );
+  }
+  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 console.log;
+    return null;
   }
-  writeLog(level, ...args) {
-    if (!this.shouldLog(level)) {
-      return;
+  async resolveDiscoveryRecord(params) {
+    const register = await this.getDiscoveryRegister({
+      directoryTopicId: params.directoryTopicId,
+      skillUid: params.skillUid
+    });
+    if (!register) {
+      return null;
     }
-    const { msg, data } = this.formatArgs(args);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const consoleMethod = this.getConsoleMethod(level);
-    if (this.prettyPrint) {
-      const levelFormatted = level.toUpperCase().padEnd(5);
-      let output = `${timestamp} ${levelFormatted} [${this.moduleContext}] ${msg}`;
-      if (data) {
-        output += "\n" + serializeLogData(data);
-      }
-      consoleMethod(output);
-    } else {
-      const logObj = {
-        timestamp,
-        level,
-        module: this.moduleContext,
-        message: msg,
-        ...data && { data }
+    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)
       };
-      consoleMethod(JSON.stringify(logObj));
     }
+    return current;
   }
-  debug(...args) {
-    this.writeLog("debug", ...args);
-  }
-  info(...args) {
-    this.writeLog("info", ...args);
-  }
-  warn(...args) {
-    this.writeLog("warn", ...args);
+  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;
   }
-  error(...args) {
-    this.writeLog("error", ...args);
+  async getLatestVersionRegister(params) {
+    const entries = await this.listVersionRegisters({
+      versionRegistryTopicId: params.versionRegistryTopicId,
+      skillUid: params.skillUid,
+      limit: 100
+    });
+    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;
   }
-  trace(...args) {
-    this.writeLog("trace", ...args);
+  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 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 };
   }
-  /**
-   * Clear all logger instances
-   * Used when switching logger implementations
-   */
-  static clearInstances() {
-    _Logger.instances.clear();
+  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})`
+      );
+    }
   }
-};
-_Logger.instances = /* @__PURE__ */ new Map();
-let Logger = _Logger;
+}
 export {
-  Logger,
-  setLoggerFactory
+  Hcs26SkillRegistryResolver
 };
 //# sourceMappingURL=standards-sdk.es118.js.map