@hashgraphonline/standards-sdk 0.1.189 → 0.1.190

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

@@ -1,687 +1,59 @@
-import { guardSessionResponseSchema, guardBalanceResponseSchema, guardFeedResponseSchema, guardOverviewResponseSchema, guardTrustByHashResponseSchema, guardTrustResolveResponseSchema, guardRevocationResponseSchema, guardPolicySchema, guardInventoryResponseSchema, guardReceiptHistoryResponseSchema, guardArtifactTimelineResponseSchema, guardInventoryDiffResponseSchema, guardAbomResponseSchema, guardReceiptExportResponseSchema, guardDeviceListResponseSchema, guardAlertPreferencesSchema, guardExceptionListResponseSchema, guardWatchlistResponseSchema, guardWatchlistLookupResponseSchema, guardPainSignalListResponseSchema, guardPainSignalAggregateResponseSchema, guardReceiptSyncResponseSchema, guardTeamPolicyPackSchema, guardPreflightVerdictResponseSchema } from "./standards-sdk.es158.js";
-import { RegistryBrokerError } from "./standards-sdk.es151.js";
-function isStatusError(error) {
-  if (error instanceof RegistryBrokerError) {
-    return true;
-  }
-  if (typeof error !== "object" || error === null || !("status" in error)) {
-    return false;
-  }
-  return typeof Reflect.get(error, "status") === "number";
-}
-function toPortalCanonicalGuardPath(path) {
-  const segments = path.split("/");
-  const findPatternStart = (size, matcher) => {
-    for (let startIndex = segments.length - size; startIndex >= 0; startIndex -= 1) {
-      if (matcher(startIndex)) {
-        return startIndex;
-      }
-    }
-    return -1;
-  };
-  const replaceAt = (startIndex, consumed) => [
-    ...segments.slice(0, startIndex),
-    "api",
-    "guard",
-    ...segments.slice(startIndex + consumed)
-  ].join("/");
-  const registryStart = findPatternStart(
-    4,
-    (startIndex) => segments[startIndex] === "registry" && segments[startIndex + 1] === "api" && /^v\d+$/.test(segments[startIndex + 2] ?? "") && segments[startIndex + 3] === "guard"
-  );
-  if (registryStart >= 0) {
-    return replaceAt(registryStart, 4);
-  }
-  const apiVersionStart = findPatternStart(
-    3,
-    (startIndex) => segments[startIndex] === "api" && /^v\d+$/.test(segments[startIndex + 1] ?? "") && segments[startIndex + 2] === "guard"
-  );
-  if (apiVersionStart >= 0) {
-    return replaceAt(apiVersionStart, 3);
-  }
-  for (let index = segments.length - 1; index >= 0; index -= 1) {
-    if (segments[index] === "guard" && segments[index - 1] !== "api") {
-      return [
-        ...segments.slice(0, index),
-        "api",
-        "guard",
-        ...segments.slice(index + 1)
-      ].join("/");
-    }
-  }
-  return path;
-}
-function buildPortalCanonicalGuardUrl(baseUrl, path) {
-  const target = new URL(path, "https://guard.local");
-  const normalizedBasePath = (() => {
-    try {
-      const base = new URL(baseUrl);
-      return base.pathname.replace(/\/+$/, "");
-    } catch {
-      return baseUrl.replace(/\/+$/, "");
-    }
-  })();
-  const requestedPath = `${normalizedBasePath}${target.pathname}`;
-  const canonicalPath = toPortalCanonicalGuardPath(requestedPath);
-  const canonicalRelativePath = `${canonicalPath}${target.search}`;
-  try {
-    const base = new URL(baseUrl);
-    return `${base.origin}${canonicalRelativePath}`;
-  } catch {
-    return canonicalRelativePath;
-  }
-}
-async function requestPortalFirstJson(client, path, init) {
-  try {
-    return await client.requestJson(path, init);
-  } catch (error) {
-    if (isStatusError(error) && (error.status === 404 || error.status === 501)) {
-      return client.requestAbsoluteJson(
-        buildPortalCanonicalGuardUrl(client.baseUrl, path),
-        init
-      );
-    }
-    throw error;
-  }
-}
-async function getGuardSession(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/auth/session",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardSessionResponseSchema,
-    "guard session response"
-  );
-}
-async function getGuardEntitlements(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/entitlements",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardSessionResponseSchema,
-    "guard entitlements response"
-  );
-}
-async function getGuardBillingBalance(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/billing/balance",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardBalanceResponseSchema,
-    "guard billing balance response"
-  );
-}
-async function getGuardFeed(client, limit) {
-  const params = new URLSearchParams();
-  if (typeof limit === "number" && Number.isFinite(limit) && Math.trunc(limit) > 0) {
-    params.set("limit", String(Math.trunc(limit)));
-  }
-  const query = params.toString();
-  const suffix = query ? `?${query}` : "";
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/feed${suffix}`,
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardFeedResponseSchema,
-    "guard feed response"
-  );
-}
-async function getGuardOverview(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/overview",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardOverviewResponseSchema,
-    "guard overview response"
-  );
-}
-async function getGuardTrustByHash(client, sha256) {
-  const normalizedHash = sha256.trim();
-  if (!normalizedHash) {
-    throw new Error("sha256 is required");
-  }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/trust/by-hash/${encodeURIComponent(normalizedHash)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTrustByHashResponseSchema,
-    "guard trust by hash response"
-  );
-}
-async function resolveGuardTrust(client, query) {
-  const params = new URLSearchParams();
-  if (query.ecosystem?.trim()) {
-    params.set("ecosystem", query.ecosystem.trim());
-  }
-  if (query.name?.trim()) {
-    params.set("name", query.name.trim());
-  }
-  if (query.version?.trim()) {
-    params.set("version", query.version.trim());
-  }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/trust/resolve${suffix}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTrustResolveResponseSchema,
-    "guard trust resolve response"
-  );
-}
-async function getGuardRevocations(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/revocations",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardRevocationResponseSchema,
-    "guard revocations response"
-  );
-}
-async function fetchGuardAdvisories(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/advisories",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardRevocationResponseSchema,
-    "guard advisories response"
-  );
-}
-async function fetchGuardPolicy(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/policy/fetch",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPolicySchema,
-    "guard policy response"
-  );
-}
-async function getGuardInventory(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardInventoryResponseSchema,
-    "guard inventory response"
-  );
-}
-async function getGuardReceiptHistory(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/history",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptHistoryResponseSchema,
-    "guard receipt history response"
-  );
-}
-async function getGuardArtifactTimeline(client, artifactId) {
-  const normalizedArtifactId = artifactId.trim();
-  if (!normalizedArtifactId) {
-    throw new Error("artifactId is required");
-  }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/history/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardArtifactTimelineResponseSchema,
-    "guard artifact timeline response"
-  );
-}
-async function exportGuardAbom(client) {
-  const raw = await requestPortalFirstJson(client, "/guard/abom", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    guardAbomResponseSchema,
-    "guard abom response"
-  );
-}
-async function exportGuardArtifactAbom(client, artifactId) {
-  const normalizedArtifactId = artifactId.trim();
-  if (!normalizedArtifactId) {
-    throw new Error("artifactId is required");
-  }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/abom/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAbomResponseSchema,
-    "guard artifact abom response"
-  );
-}
-async function exportGuardReceipts(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/export",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptExportResponseSchema,
-    "guard receipt export response"
-  );
-}
-async function getGuardInventoryDiff(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory/diff",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardInventoryDiffResponseSchema,
-    "guard inventory diff response"
-  );
-}
-async function getGuardDevices(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/devices",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardDeviceListResponseSchema,
-    "guard devices response"
-  );
-}
-async function getGuardAlertPreferences(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/alerts/preferences",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAlertPreferencesSchema,
-    "guard alert preferences response"
-  );
-}
-async function updateGuardAlertPreferences(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/alerts/preferences",
-    {
-      method: "PUT",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardAlertPreferencesSchema,
-    "guard alert preferences response"
-  );
-}
-async function getGuardExceptions(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function getGuardWatchlist(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistResponseSchema,
-    "guard watchlist response"
-  );
-}
-async function lookupGuardWatchlist(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist/lookup",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistLookupResponseSchema,
-    "guard watchlist lookup response"
-  );
-}
-async function getGuardPainSignals(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/signals/pain",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPainSignalListResponseSchema,
-    "guard pain signals response"
-  );
-}
-async function getGuardAggregatedPainSignals(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/signals/pain/aggregate",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPainSignalAggregateResponseSchema,
-    "guard aggregated pain signals response"
-  );
-}
-async function getGuardPreflightVerdict(client, path, payload) {
-  const raw = await requestPortalFirstJson(client, path, {
-    method: "POST",
-    body: payload
-  });
-  return client.parseWithSchema(
-    raw,
-    guardPreflightVerdictResponseSchema,
-    "guard preflight verdict response"
-  );
-}
-async function getGuardPreInstallVerdict(client, payload) {
-  return getGuardPreflightVerdict(
-    client,
-    "/guard/verdict/pre-install",
-    payload
-  );
-}
-async function getGuardPreExecutionVerdict(client, payload) {
-  return getGuardPreflightVerdict(
-    client,
-    "/guard/verdict/pre-execution",
-    payload
-  );
-}
-async function ingestGuardPainSignals(client, items) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/signals/pain",
-    {
-      method: "POST",
-      body: { items }
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardPainSignalListResponseSchema,
-    "guard pain signals response"
-  );
-}
-async function submitGuardReceipts(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/submit",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard receipt submit response"
-  );
-}
-async function addGuardWatchlistItem(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/watchlist",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistResponseSchema,
-    "guard watchlist response"
-  );
-}
-async function removeGuardWatchlistItem(client, artifactId) {
-  const normalizedArtifactId = artifactId.trim();
-  if (!normalizedArtifactId) {
-    throw new Error("artifactId is required");
-  }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/watchlist/${encodeURIComponent(normalizedArtifactId)}`,
-    { method: "DELETE" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardWatchlistResponseSchema,
-    "guard watchlist response"
-  );
-}
-async function addGuardException(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function requestGuardException(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/exceptions/request",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exception request response"
-  );
-}
-async function syncGuardInventory(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/inventory/sync",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard inventory sync response"
-  );
-}
-async function removeGuardException(client, exceptionId) {
-  const normalizedExceptionId = exceptionId.trim();
-  if (!normalizedExceptionId) {
-    throw new Error("exceptionId is required");
-  }
-  const raw = await requestPortalFirstJson(
-    client,
-    `/guard/exceptions/${encodeURIComponent(normalizedExceptionId)}`,
-    { method: "DELETE" }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardExceptionListResponseSchema,
-    "guard exceptions response"
-  );
-}
-async function getGuardTeamPolicyPack(client) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/team/policy-pack",
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTeamPolicyPackSchema,
-    "guard team policy pack response"
-  );
-}
-async function updateGuardTeamPolicyPack(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/team/policy-pack",
-    {
-      method: "PUT",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardTeamPolicyPackSchema,
-    "guard team policy pack response"
-  );
-}
-async function syncGuardReceipts(client, payload) {
-  const raw = await requestPortalFirstJson(
-    client,
-    "/guard/receipts/sync",
-    {
-      method: "POST",
-      body: payload
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    guardReceiptSyncResponseSchema,
-    "guard receipt sync response"
-  );
+const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const BASE = 58;
+function base58Encode(bytes) {
+  if (bytes.length === 0) return "";
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  if (zeros === bytes.length) return "1".repeat(zeros);
+  const digits = [0];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      const val = (digits[j] << 8) + carry;
+      digits[j] = val % BASE;
+      carry = val / BASE | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % BASE);
+      carry = carry / BASE | 0;
+    }
+  }
+  let result = "";
+  for (let i = 0; i < zeros; i++) result += "1";
+  for (let i = digits.length - 1; i >= 0; i--) result += ALPHABET[digits[i]];
+  return result;
+}
+function base58Decode(text) {
+  if (text.length === 0) return new Uint8Array(0);
+  let zeros = 0;
+  while (zeros < text.length && text[zeros] === "1") zeros++;
+  const b256 = [];
+  for (let i = zeros; i < text.length; i++) {
+    const ch = text[i];
+    const val = ALPHABET.indexOf(ch);
+    if (val === -1) throw new Error("Invalid Base58 character");
+    let carry = val;
+    for (let j = 0; j < b256.length; j++) {
+      const x = b256[j] * BASE + carry;
+      b256[j] = x & 255;
+      carry = x >> 8;
+    }
+    while (carry > 0) {
+      b256.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  for (let i = 0; i < zeros; i++) b256.push(0);
+  b256.reverse();
+  return Uint8Array.from(b256);
+}
+function multibaseB58btcDecode(zText) {
+  if (!zText.startsWith("z")) throw new Error("Invalid multibase base58btc");
+  return base58Decode(zText.slice(1));
 }
 export {
-  addGuardException,
-  addGuardWatchlistItem,
-  exportGuardAbom,
-  exportGuardArtifactAbom,
-  exportGuardReceipts,
-  fetchGuardAdvisories,
-  fetchGuardPolicy,
-  getGuardAggregatedPainSignals,
-  getGuardAlertPreferences,
-  getGuardArtifactTimeline,
-  getGuardBillingBalance,
-  getGuardDevices,
-  getGuardEntitlements,
-  getGuardExceptions,
-  getGuardFeed,
-  getGuardInventory,
-  getGuardInventoryDiff,
-  getGuardOverview,
-  getGuardPainSignals,
-  getGuardPreExecutionVerdict,
-  getGuardPreInstallVerdict,
-  getGuardReceiptHistory,
-  getGuardRevocations,
-  getGuardSession,
-  getGuardTeamPolicyPack,
-  getGuardTrustByHash,
-  getGuardWatchlist,
-  ingestGuardPainSignals,
-  lookupGuardWatchlist,
-  removeGuardException,
-  removeGuardWatchlistItem,
-  requestGuardException,
-  resolveGuardTrust,
-  submitGuardReceipts,
-  syncGuardInventory,
-  syncGuardReceipts,
-  updateGuardAlertPreferences,
-  updateGuardTeamPolicyPack
+  base58Decode,
+  base58Encode,
+  multibaseB58btcDecode
 };
 //# sourceMappingURL=standards-sdk.es206.js.map