@hashgraphonline/standards-sdk 0.1.189 → 0.1.191

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

@@ -1,570 +1,382 @@
-const getNested = (tx, path) => {
-  const parts = path.split(".");
-  let current = tx;
-  for (const p of parts) {
-    if (current == null) {
-      return void 0;
-    }
-    current = current[p];
-  }
-  return current;
-};
-const renderTemplate = (template, tx) => {
-  return template.replace(/\{([^}]+)\}/g, (_m, path) => {
-    const value = getNested(tx, String(path).trim());
-    if (value === null || value === void 0) {
-      return "(Unknown)";
-    }
-    return String(value);
-  });
-};
-const summarizeCryptoTransfer = (tx) => {
-  const senders = [];
-  const receivers = [];
-  if (Array.isArray(tx.transfers)) {
-    for (const transfer of tx.transfers) {
-      const originalAmountFloat = parseFloat(transfer.amount);
-      let displayStr = transfer.amount;
-      if (displayStr.startsWith("-")) {
-        displayStr = displayStr.substring(1);
-      }
-      displayStr = displayStr.replace(/\s*ℏ$/, "");
-      if (originalAmountFloat < 0) {
-        senders.push(`${transfer.accountId} (${displayStr} ℏ)`);
-      } else if (originalAmountFloat > 0) {
-        receivers.push(`${transfer.accountId} (${displayStr} ℏ)`);
-      }
-    }
-  }
-  if (senders.length > 0 && receivers.length > 0) {
-    return `Transfer of HBAR from ${senders.join(", ")} to ${receivers.join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const groupTokenTransfers = (tokenTransfers) => {
-  const groups = {};
-  for (const t of tokenTransfers) {
-    if (!groups[t.tokenId]) {
-      groups[t.tokenId] = [];
-    }
-    groups[t.tokenId].push(t);
-  }
-  return groups;
-};
-const summarizeTokenTransfers = (tx) => {
-  const tokenSummaries = [];
-  const groups = groupTokenTransfers(tx.tokenTransfers || []);
-  for (const [tokenId, transfers] of Object.entries(groups)) {
-    const tokenSenders = [];
-    const tokenReceivers = [];
-    for (const t of transfers) {
-      const amt = parseFloat(String(t.amount));
-      if (amt < 0) {
-        tokenSenders.push(`${t.accountId} (${Math.abs(amt)})`);
-      } else if (amt > 0) {
-        tokenReceivers.push(`${t.accountId} (${amt})`);
+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);
     }
-    if (tokenSenders.length > 0 && tokenReceivers.length > 0) {
-      tokenSummaries.push(
-        `Transfer of token ${tokenId} from ${tokenSenders.join(", ")} to ${tokenReceivers.join(", ")}`
-      );
-    }
-  }
-  if (tokenSummaries.length > 0) {
-    return tokenSummaries.join("; ");
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractCall = (tx) => {
-  if (!tx.contractCall) {
-    return tx.humanReadableType;
-  }
-  let summary = `Contract call to ${tx.contractCall.contractId} with ${tx.contractCall.gas} gas`;
-  if (tx.contractCall.amount > 0) {
-    summary += ` and ${tx.contractCall.amount} HBAR`;
-  }
-  if (tx.contractCall.functionName) {
-    summary += ` calling function ${tx.contractCall.functionName}`;
-  }
-  return summary;
-};
-const summarizeTokenMint = (tx) => {
-  if (tx.tokenMint) {
-    return `Mint ${tx.tokenMint.amount} tokens for token ${tx.tokenMint.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenBurn = (tx) => {
-  if (tx.tokenBurn) {
-    return `Burn ${tx.tokenBurn.amount} tokens for token ${tx.tokenBurn.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenCreate = (tx) => {
-  if (!tx.tokenCreation) {
-    return tx.humanReadableType;
-  }
-  let summary = `Create token ${tx.tokenCreation.tokenName || "(No Name)"} (${tx.tokenCreation.tokenSymbol || "(No Symbol)"})`;
-  if (tx.tokenCreation.initialSupply) {
-    summary += ` with initial supply ${tx.tokenCreation.initialSupply}`;
-  }
-  if (tx.tokenCreation.customFees && tx.tokenCreation.customFees.length > 0) {
-    summary += ` including ${tx.tokenCreation.customFees.length} custom fee(s)`;
-  }
-  return summary;
-};
-const summarizeConsensusCreateTopic = (tx) => {
-  if (!tx.consensusCreateTopic) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create new topic";
-  if (tx.consensusCreateTopic.memo) {
-    summary += ` with memo "${tx.consensusCreateTopic.memo}"`;
-  }
-  if (tx.consensusCreateTopic.autoRenewAccountId) {
-    summary += `, auto-renew by ${tx.consensusCreateTopic.autoRenewAccountId}`;
-  }
-  return summary;
-};
-const summarizeConsensusSubmitMessage = (tx) => {
-  if (!tx.consensusSubmitMessage) {
-    return tx.humanReadableType;
   }
-  let summary = "Submit message";
-  if (tx.consensusSubmitMessage.topicId) {
-    summary += ` to topic ${tx.consensusSubmitMessage.topicId}`;
-  }
-  if (tx.consensusSubmitMessage.message) {
-    if (tx.consensusSubmitMessage.messageEncoding === "utf8") {
-      const preview = tx.consensusSubmitMessage.message.substring(0, 70);
-      const needsEllipsis = tx.consensusSubmitMessage.message.length > 70;
-      summary += `: "${preview}${needsEllipsis ? "..." : ""}"`;
+  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
+  );
+  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 {
-      const byteLength = Buffer.from(
-        tx.consensusSubmitMessage.message,
-        "base64"
-      ).length;
-      summary += ` (binary message data, length: ${byteLength} bytes)`;
-    }
-  }
-  if (tx.consensusSubmitMessage.chunkInfoNumber && tx.consensusSubmitMessage.chunkInfoTotal) {
-    summary += ` (chunk ${tx.consensusSubmitMessage.chunkInfoNumber}/${tx.consensusSubmitMessage.chunkInfoTotal})`;
-  }
-  return summary;
-};
-const summarizeFileCreate = (tx) => {
-  if (!tx.fileCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create File";
-  if (tx.fileCreate.memo) {
-    summary += ` with memo "${tx.fileCreate.memo}"`;
-  }
-  if (tx.fileCreate.contents) {
-    summary += " (includes content)";
-  }
-  return summary;
-};
-const summarizeFileAppend = (tx) => {
-  if (tx.fileAppend) {
-    return `Append to File ${tx.fileAppend.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileUpdate = (tx) => {
-  if (tx.fileUpdate) {
-    return `Update File ${tx.fileUpdate.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeFileDelete = (tx) => {
-  if (tx.fileDelete) {
-    return `Delete File ${tx.fileDelete.fileId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusUpdateTopic = (tx) => {
-  if (tx.consensusUpdateTopic) {
-    return `Update Topic ${tx.consensusUpdateTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeConsensusDeleteTopic = (tx) => {
-  if (tx.consensusDeleteTopic) {
-    return `Delete Topic ${tx.consensusDeleteTopic.topicId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFreeze = (tx) => {
-  if (tx.tokenFreeze) {
-    return `Freeze Token ${tx.tokenFreeze.tokenId} for Account ${tx.tokenFreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnfreeze = (tx) => {
-  if (tx.tokenUnfreeze) {
-    return `Unfreeze Token ${tx.tokenUnfreeze.tokenId} for Account ${tx.tokenUnfreeze.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenGrantKyc = (tx) => {
-  if (tx.tokenGrantKyc) {
-    return `Grant KYC for Token ${tx.tokenGrantKyc.tokenId} to Account ${tx.tokenGrantKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenRevokeKyc = (tx) => {
-  if (tx.tokenRevokeKyc) {
-    return `Revoke KYC for Token ${tx.tokenRevokeKyc.tokenId} from Account ${tx.tokenRevokeKyc.accountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenPause = (tx) => {
-  if (tx.tokenPause) {
-    return `Pause Token ${tx.tokenPause.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUnpause = (tx) => {
-  if (tx.tokenUnpause) {
-    return `Unpause Token ${tx.tokenUnpause.tokenId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenWipe = (tx) => {
-  if (tx.tokenWipeAccount) {
-    let summary = `Wipe Token ${tx.tokenWipeAccount.tokenId} from Account ${tx.tokenWipeAccount.accountId}`;
-    if (tx.tokenWipeAccount.serialNumbers && tx.tokenWipeAccount.serialNumbers.length > 0) {
-      summary += ` (Serials: ${tx.tokenWipeAccount.serialNumbers.join(", ")})`;
+      low = mid + 1n;
     }
-    if (tx.tokenWipeAccount.amount) {
-      summary += ` (Amount: ${tx.tokenWipeAccount.amount})`;
-    }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDelete = (tx) => {
-  if (tx.tokenDelete) {
-    return `Delete Token ${tx.tokenDelete.tokenId}`;
   }
-  return tx.humanReadableType;
-};
-const summarizeTokenAssociate = (tx) => {
-  if (tx.tokenAssociate) {
-    return `Associate Account ${tx.tokenAssociate.accountId} with Tokens: ${(tx.tokenAssociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenDissociate = (tx) => {
-  if (tx.tokenDissociate) {
-    return `Dissociate Account ${tx.tokenDissociate.accountId} from Tokens: ${(tx.tokenDissociate.tokenIds || []).join(", ")}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountDelete = (tx) => {
-  if (tx.cryptoDelete) {
-    return `Delete Account ${tx.cryptoDelete.deleteAccountId}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeAccountCreate = (tx) => {
-  if (!tx.cryptoCreateAccount) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Account";
-  if (tx.cryptoCreateAccount.initialBalance && tx.cryptoCreateAccount.initialBalance !== "0") {
-    summary += ` with balance ${tx.cryptoCreateAccount.initialBalance}`;
-  }
-  if (tx.cryptoCreateAccount.alias) {
-    summary += ` (Alias: ${tx.cryptoCreateAccount.alias})`;
-  }
-  return summary;
-};
-const summarizeAccountUpdate = (tx) => {
-  if (tx.cryptoUpdateAccount) {
-    return `Update Account ${tx.cryptoUpdateAccount.accountIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeApproveAllowance = (tx) => {
-  if (tx.cryptoApproveAllowance) {
-    let count = 0;
-    if (tx.cryptoApproveAllowance.hbarAllowances) {
-      count += tx.cryptoApproveAllowance.hbarAllowances.length;
-    }
-    if (tx.cryptoApproveAllowance.tokenAllowances) {
-      count += tx.cryptoApproveAllowance.tokenAllowances.length;
-    }
-    if (tx.cryptoApproveAllowance.nftAllowances) {
-      count += tx.cryptoApproveAllowance.nftAllowances.length;
+  fromBlockCache.set(params.cacheKey, {
+    value: low,
+    expiresAt: Date.now() + params.cacheTtlMs
+  });
+  return low;
+}
+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;
+}
+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 });
     }
-    return `Approve ${count} Crypto Allowance(s)`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeDeleteAllowance = (tx) => {
-  if (tx.cryptoDeleteAllowance) {
-    const count = (tx.cryptoDeleteAllowance.nftAllowancesToRemove || []).length;
-    return `Delete ${count} NFT Crypto Allowance(s)`;
   }
-  return tx.humanReadableType;
-};
-const summarizeContractCreate = (tx) => {
-  if (tx.contractCreate) {
-    let summary = "Create Contract";
-    if (tx.contractCreate.memo) {
-      summary += ` (Memo: ${tx.contractCreate.memo})`;
+  const ensureBucket = (day) => {
+    const existing = bucketsByDay.get(day);
+    if (existing) {
+      return existing;
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractUpdate = (tx) => {
-  if (tx.contractUpdate) {
-    return `Update Contract ${tx.contractUpdate.contractIdToUpdate || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeContractDelete = (tx) => {
-  if (tx.contractDelete) {
-    let summary = `Delete Contract ${tx.contractDelete.contractIdToDelete || "(Unknown ID)"}`;
-    if (tx.contractDelete.transferAccountId) {
-      summary += ` (Transfer to Account: ${tx.contractDelete.transferAccountId})`;
-    } else if (tx.contractDelete.transferContractId) {
-      summary += ` (Transfer to Contract: ${tx.contractDelete.transferContractId})`;
+    const created = {
+      day,
+      inboundTrades: 0,
+      outboundTrades: 0,
+      volumeUsd: 0
+    };
+    bucketsByDay.set(day, created);
+    return created;
+  };
+  const aggregateLogs = async (direction) => {
+    if (toBlock < fromBlock) {
+      return;
     }
-    return summary;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenUpdate = (tx) => {
-  if (tx.tokenUpdate) {
-    return `Update Token ${tx.tokenUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenFeeScheduleUpdate = (tx) => {
-  if (tx.tokenFeeScheduleUpdate) {
-    return `Update Fee Schedule for Token ${tx.tokenFeeScheduleUpdate.tokenId || "(Unknown ID)"}`;
-  }
-  return tx.humanReadableType;
-};
-const summarizeTokenAirdrop = (tx) => {
-  if (!tx.tokenAirdrop || !tx.tokenAirdrop.tokenTransfers) {
-    return tx.humanReadableType;
-  }
-  let tokenTypes = 0;
-  let totalTransfers = 0;
-  for (const t of tx.tokenAirdrop.tokenTransfers) {
-    tokenTypes += 1;
-    totalTransfers += Array.isArray(t.transfers) ? t.transfers.length : 0;
-  }
-  return `Token Airdrop across ${tokenTypes} token(s), ${totalTransfers} transfer(s)`;
-};
-const summarizeScheduleCreate = (tx) => {
-  if (!tx.scheduleCreate) {
-    return tx.humanReadableType;
-  }
-  let summary = "Create Schedule";
-  if (tx.scheduleCreate.memo) {
-    summary += ` (Memo: ${tx.scheduleCreate.memo})`;
-  }
-  return summary;
-};
-const summarizeScheduleSign = (tx) => {
-  if (tx.scheduleSign) {
-    return "Sign Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeScheduleDelete = (tx) => {
-  if (tx.scheduleDelete) {
-    return "Delete Schedule";
-  }
-  return tx.humanReadableType;
-};
-const summarizeSystemDelete = (tx) => {
-  if (!tx.systemDelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemDelete.fileId) {
-    return `System Delete File ${tx.systemDelete.fileId}`;
-  }
-  if (tx.systemDelete.contractId) {
-    return `System Delete Contract ${tx.systemDelete.contractId}`;
-  }
-  return "System Delete";
-};
-const summarizeSystemUndelete = (tx) => {
-  if (!tx.systemUndelete) {
-    return tx.humanReadableType;
-  }
-  if (tx.systemUndelete.fileId) {
-    return `System Undelete File ${tx.systemUndelete.fileId}`;
-  }
-  if (tx.systemUndelete.contractId) {
-    return `System Undelete Contract ${tx.systemUndelete.contractId}`;
-  }
-  return "System Undelete";
-};
-const summarizeFreeze = (tx) => {
-  return "Network Freeze";
-};
-const summarizeEthereumTransaction = (tx) => {
-  return "Ethereum Transaction";
-};
-const summarizeUncheckedSubmit = (tx) => {
-  if (tx.uncheckedSubmit && tx.uncheckedSubmit.topicId) {
-    return `Unchecked Submit to topic ${tx.uncheckedSubmit.topicId}`;
-  }
-  return "Unchecked Submit";
-};
-const summarizeNodeCreate = (tx) => {
-  return "Create Node";
-};
-const summarizeNodeUpdate = (tx) => {
-  return "Update Node";
-};
-const summarizeNodeDelete = (tx) => {
-  return "Delete Node";
-};
-const summarizeAtomicBatch = (tx) => {
-  const count = Array.isArray(tx.atomicBatch?.transactions) ? tx.atomicBatch.transactions.length : 0;
-  return `Atomic Batch (${count} transaction(s))`;
-};
-const transactionSummaryRegistry = {
-  CRYPTOTRANSFER: { fn: summarizeCryptoTransfer },
-  cryptoTransfer: { fn: summarizeCryptoTransfer },
-  CONTRACTCALL: { fn: summarizeContractCall },
-  contractCall: { fn: summarizeContractCall },
-  TOKENMINT: { fn: summarizeTokenMint },
-  tokenMint: { fn: summarizeTokenMint },
-  TOKENBURN: { fn: summarizeTokenBurn },
-  tokenBurn: { fn: summarizeTokenBurn },
-  TOKENCREATE: { fn: summarizeTokenCreate },
-  tokenCreation: { fn: summarizeTokenCreate },
-  TOPICCREATE: { fn: summarizeConsensusCreateTopic },
-  consensusCreateTopic: { fn: summarizeConsensusCreateTopic },
-  CONSENSUSSUBMITMESSAGE: { fn: summarizeConsensusSubmitMessage },
-  consensusSubmitMessage: { fn: summarizeConsensusSubmitMessage },
-  TOPICUPDATE: { fn: summarizeConsensusUpdateTopic },
-  consensusUpdateTopic: { fn: summarizeConsensusUpdateTopic },
-  TOPICDELETE: { fn: summarizeConsensusDeleteTopic },
-  consensusDeleteTopic: { fn: summarizeConsensusDeleteTopic },
-  FILECREATE: { fn: summarizeFileCreate },
-  fileCreate: { fn: summarizeFileCreate },
-  FILEAPPEND: { fn: summarizeFileAppend },
-  fileAppend: { fn: summarizeFileAppend },
-  FILEUPDATE: { fn: summarizeFileUpdate },
-  fileUpdate: { fn: summarizeFileUpdate },
-  FILEDELETE: { fn: summarizeFileDelete },
-  fileDelete: { fn: summarizeFileDelete },
-  TOKENUPDATE: { fn: summarizeTokenUpdate },
-  tokenUpdate: { fn: summarizeTokenUpdate },
-  TOKENFEESCHEDULEUPDATE: { fn: summarizeTokenFeeScheduleUpdate },
-  tokenFeeScheduleUpdate: { fn: summarizeTokenFeeScheduleUpdate },
-  TOKENFREEZE: { fn: summarizeTokenFreeze },
-  tokenFreeze: { fn: summarizeTokenFreeze },
-  TOKENUNFREEZE: { fn: summarizeTokenUnfreeze },
-  tokenUnfreeze: { fn: summarizeTokenUnfreeze },
-  TOKENGRANTKYC: { fn: summarizeTokenGrantKyc },
-  tokenGrantKyc: { fn: summarizeTokenGrantKyc },
-  TOKENREVOKEKYC: { fn: summarizeTokenRevokeKyc },
-  tokenRevokeKyc: { fn: summarizeTokenRevokeKyc },
-  TOKENPAUSE: { fn: summarizeTokenPause },
-  tokenPause: { fn: summarizeTokenPause },
-  TOKENUNPAUSE: { fn: summarizeTokenUnpause },
-  tokenUnpause: { fn: summarizeTokenUnpause },
-  TOKENWIPE: { fn: summarizeTokenWipe },
-  TOKENWIPEACCOUNT: { fn: summarizeTokenWipe },
-  tokenWipe: { fn: summarizeTokenWipe },
-  tokenWipeAccount: { fn: summarizeTokenWipe },
-  TOKENDELETE: { fn: summarizeTokenDelete },
-  tokenDelete: { fn: summarizeTokenDelete },
-  TOKENASSOCIATE: { fn: summarizeTokenAssociate },
-  tokenAssociate: { fn: summarizeTokenAssociate },
-  TOKENDISSOCIATE: { fn: summarizeTokenDissociate },
-  tokenDissociate: { fn: summarizeTokenDissociate },
-  ACCOUNTDELETE: { fn: summarizeAccountDelete },
-  cryptoDelete: { fn: summarizeAccountDelete },
-  ACCOUNTCREATE: { fn: summarizeAccountCreate },
-  cryptoCreateAccount: { fn: summarizeAccountCreate },
-  ACCOUNTUPDATE: { fn: summarizeAccountUpdate },
-  cryptoUpdateAccount: { fn: summarizeAccountUpdate },
-  APPROVEALLOWANCE: { fn: summarizeApproveAllowance },
-  cryptoApproveAllowance: { fn: summarizeApproveAllowance },
-  DELETEALLOWANCE: { fn: summarizeDeleteAllowance },
-  cryptoDeleteAllowance: { fn: summarizeDeleteAllowance },
-  CONTRACTCREATE: { fn: summarizeContractCreate },
-  contractCreate: { fn: summarizeContractCreate },
-  CONTRACTUPDATE: { fn: summarizeContractUpdate },
-  contractUpdate: { fn: summarizeContractUpdate },
-  CONTRACTDELETE: { fn: summarizeContractDelete },
-  contractDelete: { fn: summarizeContractDelete },
-  TOKENAIRDROP: { fn: summarizeTokenAirdrop },
-  tokenAirdrop: { fn: summarizeTokenAirdrop },
-  SCHEDULECREATE: { fn: summarizeScheduleCreate },
-  scheduleCreate: { fn: summarizeScheduleCreate },
-  SCHEDULESIGN: { fn: summarizeScheduleSign },
-  scheduleSign: { fn: summarizeScheduleSign },
-  SCHEDULEDELETE: { fn: summarizeScheduleDelete },
-  scheduleDelete: { fn: summarizeScheduleDelete },
-  SYSTEMDELETE: { fn: summarizeSystemDelete },
-  systemDelete: { fn: summarizeSystemDelete },
-  SYSTEMUNDELETE: { fn: summarizeSystemUndelete },
-  systemUndelete: { fn: summarizeSystemUndelete },
-  FREEZE: { fn: summarizeFreeze },
-  freeze: { fn: summarizeFreeze },
-  ETHEREUMTRANSACTION: { fn: summarizeEthereumTransaction },
-  ethereumTransaction: { fn: summarizeEthereumTransaction },
-  UNCHECKEDSUBMIT: { fn: summarizeUncheckedSubmit },
-  uncheckedSubmit: { fn: summarizeUncheckedSubmit },
-  NODECREATE: { fn: summarizeNodeCreate },
-  nodeCreate: { fn: summarizeNodeCreate },
-  NODEUPDATE: { fn: summarizeNodeUpdate },
-  nodeUpdate: { fn: summarizeNodeUpdate },
-  NODEDELETE: { fn: summarizeNodeDelete },
-  nodeDelete: { fn: summarizeNodeDelete },
-  ATOMICBATCH: { fn: summarizeAtomicBatch },
-  atomicBatch: { fn: summarizeAtomicBatch }
-};
-const resolveTransactionSummary = (tx) => {
-  const spec = transactionSummaryRegistry[tx.type];
-  if (spec) {
-    if (spec.fn) {
-      return spec.fn(tx);
-    }
-    if (spec.template) {
-      return renderTemplate(spec.template, tx);
-    }
-  }
-  const hrSpec = transactionSummaryRegistry[tx.humanReadableType];
-  if (hrSpec) {
-    if (hrSpec.fn) {
-      return hrSpec.fn(tx);
-    }
-    if (hrSpec.template) {
-      return renderTemplate(hrSpec.template, tx);
+    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;
+        }
+        const value = log.args.value ?? 0n;
+        if (value <= 0n) {
+          continue;
+        }
+        const day = await resolveBlockDay({
+          client,
+          blockNumber,
+          cacheTtlMs: ttlMs,
+          maxRetries
+        });
+        const bucket = ensureBucket(day);
+        if (direction === "inbound") {
+          bucket.inboundTrades += 1;
+        } else {
+          bucket.outboundTrades += 1;
+        }
+        const amount = Number.parseFloat(formatUnits(value, decimals));
+        if (Number.isFinite(amount) && amount > 0) {
+          bucket.volumeUsd = round6(bucket.volumeUsd + amount);
+        }
+      }
+      start = end + 1n;
     }
-  }
-  if (tx.type === "cryptoTransfer" || tx.type === "CRYPTOTRANSFER") {
-    return summarizeCryptoTransfer(tx);
-  }
-  if (tx.contractCall) {
-    return summarizeContractCall(tx);
-  }
-  if (Array.isArray(tx.tokenTransfers) && tx.tokenTransfers.length > 0) {
-    return summarizeTokenTransfers(tx);
-  }
-  if (tx.humanReadableType && tx.humanReadableType !== "Unknown Transaction") {
-    return tx.humanReadableType;
-  }
-  return "Unknown Transaction";
-};
+  };
+  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
+  };
+}
 export {
-  resolveTransactionSummary,
-  transactionSummaryRegistry
+  fetchX402OnchainUsageState
 };
 //# sourceMappingURL=standards-sdk.es135.js.map