@hashgraphonline/standards-sdk 0.1.190 → 0.1.191

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

@@ -1,382 +1,234 @@
-import { getAddress, http, createPublicClient, fallback, formatUnits } from "viem";
-import { baseSepolia, base } from "viem/chains";
-const TRANSFER_EVENT_ABI = [
-  {
-    type: "event",
-    name: "Transfer",
-    inputs: [
-      { indexed: true, name: "from", type: "address" },
-      { indexed: true, name: "to", type: "address" },
-      { indexed: false, name: "value", type: "uint256" }
-    ],
-    anonymous: false
-  }
-];
-const DECIMALS_ABI = [
-  {
-    type: "function",
-    name: "decimals",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  }
-];
-const NETWORK_CONFIG = {
-  base: {
-    chain: base,
-    rpcUrls: [
-      "https://mainnet.base.org",
-      "https://1rpc.io/base",
-      "https://base.llamarpc.com",
-      "https://base-rpc.publicnode.com"
-    ],
-    usdcAddresses: /* @__PURE__ */ new Set(["0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"])
-  },
-  "base-sepolia": {
-    chain: baseSepolia,
-    rpcUrls: [
-      "https://sepolia.base.org",
-      "https://1rpc.io/base-sepolia",
-      "https://base-sepolia-rpc.publicnode.com"
-    ],
-    usdcAddresses: /* @__PURE__ */ new Set(["0x036cbd53842c5426634e7929541ec2318f3dcf7e"])
-  }
-};
-const toNetwork = (value) => {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "base") {
-    return "base";
-  }
-  if (normalized === "base-sepolia" || normalized === "basesepolia") {
-    return "base-sepolia";
-  }
-  return null;
-};
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const round6 = (value) => Math.round(value * 1e6) / 1e6;
-const toDayStringUtc = (timestampMs) => {
-  const date = new Date(timestampMs);
-  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(
-    date.getUTCDate()
-  ).padStart(2, "0")}`;
-};
-const decimalsCache = /* @__PURE__ */ new Map();
-const fromBlockCache = /* @__PURE__ */ new Map();
-const blockDayCache = /* @__PURE__ */ new Map();
-async function withRetries(operation, maxRetries, baseDelayMs) {
-  let lastError;
-  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      if (attempt >= maxRetries) {
-        throw error;
-      }
-      await sleep(baseDelayMs * 2 ** attempt);
-    }
-  }
-  throw lastError;
-}
-const keepRollingDays = (buckets, keepDays) => {
-  const keep = /* @__PURE__ */ new Set();
-  const today = toDayStringUtc(Date.now());
-  const [year, month, day] = today.split("-").map((v) => Number.parseInt(v, 10));
-  const baseUtc = Date.UTC(year, month - 1, day);
-  for (let offset = 0; offset < keepDays; offset += 1) {
-    keep.add(toDayStringUtc(baseUtc - offset * 24 * 60 * 60 * 1e3));
-  }
-  return buckets.filter((bucket) => keep.has(bucket.day)).sort((a, b) => a.day < b.day ? -1 : a.day > b.day ? 1 : 0).slice(-keepDays);
-};
-function parseCursor(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  const cursor = value;
-  if (typeof cursor.asset !== "string" || typeof cursor.payTo !== "string" || typeof cursor.lastScannedBlock !== "number" || !Number.isFinite(cursor.lastScannedBlock) || cursor.lastScannedBlock < 0 || !Array.isArray(cursor.daily)) {
-    return null;
-  }
-  const network = toNetwork(cursor.network);
-  if (!network) {
-    return null;
-  }
-  const daily = cursor.daily.filter(
-    (entry) => !!entry && typeof entry === "object" && typeof entry.day === "string" && typeof entry.inboundTrades === "number" && Number.isFinite(entry.inboundTrades) && typeof entry.outboundTrades === "number" && Number.isFinite(entry.outboundTrades) && typeof entry.volumeUsd === "number" && Number.isFinite(entry.volumeUsd)
-  ).map((entry) => ({
-    day: entry.day,
-    inboundTrades: Math.max(0, Math.floor(entry.inboundTrades)),
-    outboundTrades: Math.max(0, Math.floor(entry.outboundTrades)),
-    volumeUsd: round6(Math.max(0, entry.volumeUsd))
-  }));
-  return {
-    network,
-    asset: cursor.asset,
-    payTo: cursor.payTo,
-    lastScannedBlock: Math.floor(cursor.lastScannedBlock),
-    daily
-  };
-}
-async function resolveDecimals(params) {
-  if (params.isUsdc) {
-    return 6;
-  }
-  const cacheKey = `${params.client.chain?.id ?? "unknown"}:${params.asset}:decimals`;
-  const cached = decimalsCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.value;
-  }
-  const decimals = await withRetries(
-    async () => {
-      const value = await params.client.readContract({
-        address: params.asset,
-        abi: DECIMALS_ABI,
-        functionName: "decimals"
-      });
-      return Number(value);
-    },
-    params.maxRetries,
-    200
+import { readString, isJsonObject } from "./standards-sdk.es201.js";
+import "./standards-sdk.es184.js";
+import "./standards-sdk.es198.js";
+import "./standards-sdk.es199.js";
+import "./standards-sdk.es200.js";
+import "./standards-sdk.es183.js";
+import { parseTimestampMs } from "./standards-sdk.es123.js";
+import { requestJson, Hcs25CollectorHttpError, isTimeoutError } from "./standards-sdk.es122.js";
+import { fetchX402OnchainUsageState } from "./standards-sdk.es135.js";
+const summaryValues = (summary) => ({
+  x402UsageSummary: summary ? {
+    volume7dUsd: summary.volume7dUsd ?? 0,
+    volume24hUsd: summary.volume24hUsd ?? 0,
+    inboundTrades7d: summary.inboundTrades7d ?? 0,
+    outboundTrades7d: summary.outboundTrades7d ?? 0
+  } : null
+});
+function hasProtocol(subject, wanted) {
+  const normalized = wanted.toLowerCase();
+  const direct = subject.protocol?.toLowerCase();
+  if (direct === normalized) {
+    return true;
+  }
+  const metadataProtocol = typeof subject.metadata?.protocol === "string" ? subject.metadata.protocol.toLowerCase() : null;
+  if (metadataProtocol === normalized) {
+    return true;
+  }
+  const list = subject.protocols;
+  return Array.isArray(list) && list.some(
+    (entry) => typeof entry === "string" && entry.toLowerCase() === normalized
   );
-  const normalized = Number.isFinite(decimals) ? Math.max(0, Math.min(255, Math.floor(decimals))) : 18;
-  decimalsCache.set(cacheKey, {
-    value: normalized,
-    expiresAt: Date.now() + params.cacheTtlMs
-  });
-  return normalized;
 }
-async function estimateFromBlockByTimestamp(params) {
-  const cached = fromBlockCache.get(params.cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.value;
-  }
-  const latestBlockNumber = await withRetries(
-    () => params.client.getBlockNumber(),
-    params.maxRetries,
-    200
-  );
-  const latest = await withRetries(
-    () => params.client.getBlock({ blockNumber: latestBlockNumber }),
-    params.maxRetries,
-    200
-  );
-  const probeDelta = 5000n;
-  const probeBlockNumber = latestBlockNumber > probeDelta ? latestBlockNumber - probeDelta : 0n;
-  const probe = await withRetries(
-    () => params.client.getBlock({ blockNumber: probeBlockNumber }),
-    params.maxRetries,
-    200
-  );
-  const latestTs = BigInt(latest.timestamp);
-  const probeTs = BigInt(probe.timestamp);
-  const deltaSeconds = latestTs > probeTs ? latestTs - probeTs : 0n;
-  const secondsPerBlock = deltaSeconds > 0n ? Number(deltaSeconds) / Number(latestBlockNumber - probeBlockNumber || 1n) : 2;
-  const secondsAgo = latestTs > params.targetTimestampSec ? latestTs - params.targetTimestampSec : 0n;
-  const approxBlocksAgo = secondsPerBlock > 0 ? BigInt(Math.ceil(Number(secondsAgo) / secondsPerBlock)) : 0n;
-  const margin = 1000n;
-  let low = latestBlockNumber > approxBlocksAgo + margin ? latestBlockNumber - approxBlocksAgo - margin : 0n;
-  let high = latestBlockNumber;
-  while (low < high) {
-    const mid = (low + high) / 2n;
-    const block = await withRetries(
-      () => params.client.getBlock({ blockNumber: mid }),
-      params.maxRetries,
-      200
-    );
-    if (BigInt(block.timestamp) >= params.targetTimestampSec) {
-      high = mid;
-    } else {
-      low = mid + 1n;
-    }
-  }
-  fromBlockCache.set(params.cacheKey, {
-    value: low,
-    expiresAt: Date.now() + params.cacheTtlMs
-  });
-  return low;
+function hasX402Config(subject) {
+  const metadata = subject.metadata ?? {};
+  const configured = readString(metadata, "payTo") !== null && readString(metadata, "asset") !== null && readString(metadata, "network") !== null;
+  return configured || hasProtocol(subject, "x402");
 }
-async function resolveBlockDay(params) {
-  const cacheKey = `${params.client.chain?.id ?? "unknown"}:${params.blockNumber.toString()}:day`;
-  const cached = blockDayCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.value;
-  }
-  const block = await withRetries(
-    () => params.client.getBlock({ blockNumber: params.blockNumber }),
-    params.maxRetries,
-    200
-  );
-  const day = toDayStringUtc(Number(block.timestamp) * 1e3);
-  blockDayCache.set(cacheKey, {
-    value: day,
-    expiresAt: Date.now() + params.cacheTtlMs
-  });
-  return day;
+function readCursor(subject) {
+  const raw = subject.metadata?.x402UsageCursor;
+  return raw === void 0 ? void 0 : raw;
 }
-async function fetchX402OnchainUsageState(params, options = {}) {
-  const network = toNetwork(params.network);
-  if (!network) {
-    return { summary: null, cursor: null };
-  }
-  const config = NETWORK_CONFIG[network];
-  if (typeof params.asset !== "string" || typeof params.payTo !== "string") {
-    return { summary: null, cursor: null };
-  }
-  let asset;
-  let payTo;
-  try {
-    asset = getAddress(params.asset.trim());
-    payTo = getAddress(params.payTo.trim());
-  } catch {
-    return { summary: null, cursor: null };
-  }
-  const now = Date.now();
-  const ttlMs = typeof options.ttlMs === "number" && Number.isFinite(options.ttlMs) && options.ttlMs > 0 ? options.ttlMs : 30 * 60 * 1e3;
-  const maxRetries = typeof options.maxRetries === "number" && Number.isFinite(options.maxRetries) && options.maxRetries >= 0 ? Math.floor(options.maxRetries) : 2;
-  const chunkSizeBlocks = typeof options.chunkSizeBlocks === "number" && Number.isFinite(options.chunkSizeBlocks) && options.chunkSizeBlocks > 0 ? BigInt(Math.floor(options.chunkSizeBlocks)) : 50000n;
-  const rpcUrls = options.rpcUrls?.[network]?.length ? [...options.rpcUrls[network]] : config.rpcUrls;
-  const transports = rpcUrls.map((url) => http(url));
-  if (transports.length === 0) {
-    return { summary: null, cursor: null };
-  }
-  const client = createPublicClient({
-    chain: config.chain,
-    transport: transports.length > 1 ? fallback(transports) : transports[0]
-  });
-  const assetLower = asset.toLowerCase();
-  const payToLower = payTo.toLowerCase();
-  const decimals = await resolveDecimals({
-    client,
-    asset,
-    isUsdc: config.usdcAddresses.has(assetLower),
-    cacheTtlMs: ttlMs,
-    maxRetries
-  });
-  const days = typeof options.days === "number" && Number.isFinite(options.days) && options.days > 0 ? Math.min(14, Math.max(1, Math.floor(options.days))) : 7;
-  const targetTimestampSec = BigInt(
-    Math.floor((now - days * 24 * 60 * 60 * 1e3) / 1e3)
-  );
-  const windowFromBlock = await estimateFromBlockByTimestamp({
-    client,
-    targetTimestampSec,
-    cacheKey: `${network}:${assetLower}:${payToLower}:fromBlock:${days}`,
-    cacheTtlMs: ttlMs,
-    maxRetries
-  });
-  const toBlock = await client.getBlockNumber();
-  const parsedCursor = parseCursor(params.cursor);
-  const hasMatchingCursor = parsedCursor !== null && parsedCursor.network === network && parsedCursor.asset.toLowerCase() === assetLower && parsedCursor.payTo.toLowerCase() === payToLower;
-  const cursorFromBlock = hasMatchingCursor && parsedCursor ? BigInt(Math.max(0, parsedCursor.lastScannedBlock + 1)) : windowFromBlock;
-  const fromBlock = cursorFromBlock < windowFromBlock ? windowFromBlock : cursorFromBlock;
-  const shouldResync = !hasMatchingCursor || cursorFromBlock < windowFromBlock;
-  const bucketsByDay = /* @__PURE__ */ new Map();
-  if (!shouldResync && parsedCursor) {
-    for (const bucket of keepRollingDays(parsedCursor.daily, days)) {
-      bucketsByDay.set(bucket.day, { ...bucket });
-    }
-  }
-  const ensureBucket = (day) => {
-    const existing = bucketsByDay.get(day);
-    if (existing) {
-      return existing;
+function createX402SignalAdapter(options = {}) {
+  const source = options.source ?? "onchain";
+  const ttlMs = options.ttlMs ?? 6 * 60 * 60 * 1e3;
+  const failureTtlMs = options.failureTtlMs ?? 3 * 60 * 60 * 1e3;
+  const fetchUsage = options.fetchUsageState ?? fetchX402OnchainUsageState;
+  const isHttpSource = typeof source === "string" && source !== "onchain";
+  const isUrlFn = typeof source === "function";
+  const collect = async (subject, context) => {
+    const now = context.now.toISOString();
+    const metadata = subject.metadata ?? {};
+    const payTo = readString(metadata, "payTo");
+    const asset = readString(metadata, "asset");
+    const network = readString(metadata, "network");
+    const cursor = readCursor(subject);
+    if (!context.force) {
+      const storedStatus = readString(metadata, "x402UsageStatus");
+      const storedUpdatedMs = parseTimestampMs(metadata.x402UsageUpdatedAt);
+      if (storedStatus && storedUpdatedMs !== null) {
+        const ttl = storedStatus === "ok" ? ttlMs : failureTtlMs;
+        if (context.now.getTime() - storedUpdatedMs < ttl) {
+          const storedSummary = isJsonObject(metadata.x402UsageSummary) ? metadata.x402UsageSummary : null;
+          return [
+            {
+              signalId: "x402.usage",
+              status: storedStatus === "ok" ? "ok" : "missing",
+              value: storedSummary && typeof storedSummary.volume7dUsd === "number" ? storedSummary.volume7dUsd : null,
+              provenance: {
+                source: "x402",
+                subjectId: payTo ?? subject.id,
+                fetchedAt: metadata.x402UsageUpdatedAt
+              }
+            }
+          ];
+        }
+      }
     }
-    const created = {
-      day,
-      inboundTrades: 0,
-      outboundTrades: 0,
-      volumeUsd: 0
-    };
-    bucketsByDay.set(day, created);
-    return created;
-  };
-  const aggregateLogs = async (direction) => {
-    if (toBlock < fromBlock) {
-      return;
+    if (!options.fetchUsageState && (isHttpSource || isUrlFn)) {
+      const resolved = isUrlFn ? source(subject) : source.replace("{payTo}", encodeURIComponent(payTo ?? "")).replace("{asset}", encodeURIComponent(asset ?? "")).replace("{network}", encodeURIComponent(network ?? ""));
+      const url = typeof resolved === "string" ? resolved : null;
+      if (!url) {
+        return [{ signalId: "x402.usage", status: "missing" }];
+      }
+      const urlWithCursor = cursor && isJsonObject(cursor) && typeof cursor.cursor === "string" ? `${url}${url.includes("?") ? "&" : "?"}cursor=${encodeURIComponent(cursor.cursor)}` : url;
+      try {
+        const data = await requestJson(urlWithCursor, {
+          fetch: context.fetch,
+          timeoutMs: context.timeoutMs,
+          signal: context.signal
+        });
+        const summary = data.summary ?? data;
+        const values = {
+          x402UsageStatus: "ok",
+          x402UsageUpdatedAt: now,
+          x402UsageSource: "indexer",
+          ...summaryValues(summary)
+        };
+        const nextCursor = data.cursor ?? cursor;
+        if (nextCursor !== void 0) {
+          values.x402UsageCursor = nextCursor;
+        }
+        return [
+          {
+            signalId: "x402.usage",
+            status: "ok",
+            value: summary.volume7dUsd ?? null,
+            fields: [{ scope: "root", values }],
+            provenance: {
+              source: "x402",
+              sourceUrl: url,
+              subjectId: payTo ?? subject.id,
+              fetchedAt: now
+            }
+          }
+        ];
+      } catch (error) {
+        const missing = error instanceof Hcs25CollectorHttpError && error.status === 404;
+        const status = missing ? "missing" : isTimeoutError(error) ? "timeout" : "error";
+        return [
+          {
+            signalId: "x402.usage",
+            status,
+            fields: [
+              {
+                scope: "root",
+                values: {
+                  x402UsageStatus: missing ? "missing" : "error",
+                  x402UsageUpdatedAt: now,
+                  x402UsageSource: "indexer"
+                }
+              }
+            ]
+          }
+        ];
+      }
     }
-    for (let start = fromBlock; start <= toBlock; ) {
-      const end = start + chunkSizeBlocks - 1n <= toBlock ? start + chunkSizeBlocks - 1n : toBlock;
-      const args = direction === "inbound" ? { to: payTo } : { from: payTo };
-      const logs = await withRetries(
-        () => client.getLogs({
-          address: asset,
-          event: TRANSFER_EVENT_ABI[0],
-          args,
-          fromBlock: start,
-          toBlock: end
-        }),
-        maxRetries,
-        200
-      );
-      for (const log of logs) {
-        const blockNumber = log.blockNumber ?? null;
-        if (!blockNumber) {
-          continue;
+    if (!payTo || !asset || !network) {
+      return [
+        {
+          signalId: "x402.usage",
+          status: "missing",
+          fields: [
+            {
+              scope: "root",
+              values: {
+                x402UsageStatus: "missing",
+                x402UsageUpdatedAt: now,
+                x402UsageSource: "onchain",
+                x402UsageSummary: null
+              }
+            }
+          ]
         }
-        const value = log.args.value ?? 0n;
-        if (value <= 0n) {
-          continue;
+      ];
+    }
+    try {
+      const { summary, cursor: nextCursor } = await fetchUsage(
+        { network, asset, payTo, cursor },
+        {
+          days: options.days,
+          ttlMs: options.ttlMs,
+          maxRetries: options.maxRetries,
+          chunkSizeBlocks: options.chunkSizeBlocks,
+          rpcUrls: options.rpcUrls
         }
-        const day = await resolveBlockDay({
-          client,
-          blockNumber,
-          cacheTtlMs: ttlMs,
-          maxRetries
-        });
-        const bucket = ensureBucket(day);
-        if (direction === "inbound") {
-          bucket.inboundTrades += 1;
-        } else {
-          bucket.outboundTrades += 1;
+      );
+      const values = {
+        x402UsageStatus: summary ? "ok" : "missing",
+        x402UsageUpdatedAt: now,
+        x402UsageSource: "onchain",
+        ...summaryValues(summary)
+      };
+      if (nextCursor !== null) {
+        values.x402UsageCursor = nextCursor;
+      } else if (cursor !== void 0) {
+        values.x402UsageCursor = cursor;
+      }
+      return [
+        {
+          signalId: "x402.usage",
+          status: summary ? "ok" : "missing",
+          value: summary?.volume7dUsd ?? null,
+          fields: [{ scope: "root", values }],
+          provenance: {
+            source: "x402",
+            subjectId: payTo,
+            fetchedAt: now,
+            params: { network, asset, source: "onchain" }
+          }
         }
-        const amount = Number.parseFloat(formatUnits(value, decimals));
-        if (Number.isFinite(amount) && amount > 0) {
-          bucket.volumeUsd = round6(bucket.volumeUsd + amount);
+      ];
+    } catch (error) {
+      return [
+        {
+          signalId: "x402.usage",
+          status: isTimeoutError(error) ? "timeout" : "error",
+          fields: [
+            {
+              scope: "root",
+              values: {
+                x402UsageStatus: "error",
+                x402UsageUpdatedAt: now,
+                x402UsageSource: "onchain",
+                x402UsageSummary: null,
+                ...cursor !== void 0 ? { x402UsageCursor: cursor } : {}
+              }
+            }
+          ]
         }
-      }
-      start = end + 1n;
+      ];
     }
   };
-  await aggregateLogs("inbound");
-  await aggregateLogs("outbound");
-  const mergedDaily = keepRollingDays(Array.from(bucketsByDay.values()), days);
-  const inboundTrades7d = mergedDaily.reduce(
-    (sum, bucket) => sum + bucket.inboundTrades,
-    0
-  );
-  const outboundTrades7d = mergedDaily.reduce(
-    (sum, bucket) => sum + bucket.outboundTrades,
-    0
-  );
-  const volume7dUsd = round6(
-    mergedDaily.reduce((sum, bucket) => sum + bucket.volumeUsd, 0)
-  );
-  const today = toDayStringUtc(now);
-  const volume24hUsd = round6(
-    mergedDaily.filter((bucket) => bucket.day === today).reduce((sum, bucket) => sum + bucket.volumeUsd, 0)
-  );
-  const cursor = {
-    network,
-    asset: assetLower,
-    payTo: payToLower,
-    lastScannedBlock: Number(toBlock),
-    daily: mergedDaily
-  };
-  if (inboundTrades7d + outboundTrades7d <= 0) {
-    return { summary: null, cursor };
-  }
   return {
-    summary: {
-      volume7dUsd,
-      volume24hUsd,
-      inboundTrades7d,
-      outboundTrades7d
-    },
-    cursor
+    id: "x402",
+    produces: ["x402.usage"],
+    timeoutMs: options.timeoutMs,
+    // On-chain scans need network+asset+payTo; HTTP/custom sources only
+    // need a payTo (or the x402 protocol marker) to query.
+    appliesTo: options.appliesTo ?? ((subject) => {
+      if (hasX402Config(subject)) {
+        return true;
+      }
+      if (!isHttpSource && !isUrlFn && options.fetchUsageState === void 0) {
+        return false;
+      }
+      return readString(subject.metadata ?? {}, "payTo") !== null;
+    }),
+    collect
   };
 }
 export {
-  fetchX402OnchainUsageState
+  createX402SignalAdapter
 };
 //# sourceMappingURL=standards-sdk.es134.js.map