@antseed/node 0.2.118 → 0.2.120

package/dist/node.js

@@ -1,6 +1,9 @@
 import { EventEmitter } from "node:events";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { IDENTITY_HISTORY_TTL_MS, IdentityHistoryCollector } from './reputation/identity-history.js';
+import { computeTrustScore } from './reputation/trust-score.js';
+import { TrustSignalsClient } from './payments/evm/trust-signals-client.js';
 import { loadOrCreateIdentity } from "./p2p/identity.js";
 import { peerIdToAddress } from "./types/peer.js";
 import { MeteringStorage } from "./metering/storage.js";
@@ -31,6 +34,7 @@ import { signUtf8 } from "./p2p/identity.js";
 import { BalanceManager, DepositsClient, ChannelsClient, FreeUsageClient, BuyerFreeUsageManager, SellerFreeUsageManager, StakingClient, ChannelStore, CHANNEL_KIND, CHANNEL_ROLE, CHANNEL_STATUS, } from "./payments/index.js";
 import { debugLog, debugWarn } from "./utils/debug.js";
 import { parsePublicAddress } from "./discovery/public-address.js";
+import { sanitizePeerDisplayName } from "./discovery/display-name.js";
 import { BuyerPaymentManager } from "./payments/buyer-payment-manager.js";
 import { BuyerPaymentNegotiator } from "./payments/buyer-payment-negotiator.js";
 import { RpcHealthMonitor } from "./payments/rpc-health.js";
@@ -40,8 +44,16 @@ import { SellerPaymentManager } from "./payments/seller-payment-manager.js";
 import { IdentityClient } from "./payments/evm/identity-client.js";
 import { SellerRequestHandler } from "./seller-request-handler.js";
 import { BuyerRequestHandler, } from "./buyer-request-handler.js";
-import { buildSybilContext, computeOnChainScore, computeOnChainScoreWithRisk, computeOnChainSybilRisk, computeOnChainTrust, } from "./reputation/on-chain-reputation.js";
+import { buildSybilContext, computeOnChainSybilRisk, } from "./reputation/sybil-risk.js";
 import { buyerFault } from "./errors.js";
+/** Store the trust score on the peer; leaves the fields untouched when the peer is unscored. */
+function applyTrust(peer) {
+    const trust = computeTrustScore(peer);
+    if (!trust)
+        return;
+    peer.trust = trust;
+    peer.onChainReputationScore = trust.score;
+}
 const EMPTY_BUYER_USAGE = {
     totalRequests: 0,
     totalInputTokens: '0',
@@ -52,7 +64,7 @@ const EMPTY_BUYER_USAGE = {
     channels: [],
     services: [],
 };
-const EXTERNAL_VERIFICATION_RESULT_TTL_MS = 15 * 60_000;
+const EXTERNAL_VERIFICATION_RESULT_TTL_MS = IDENTITY_HISTORY_TTL_MS;
 /** How long one relayer gets exclusive first refusal on a sweep offer before
  *  it passes to the next candidate. The relayer replies 'submitted' right
  *  after its local checks + one Base RPC simulation (~1-2s on healthy RPCs),
@@ -88,6 +100,8 @@ export class AntseedNode extends EventEmitter {
     _buyerFreeUsageManager = null;
     _sellerFreeUsageManager = null;
     _stakingClient = null;
+    /** Batched reader for the on-chain inputs of the buyer trust score. */
+    _trustSignalsClient = null;
     _sellerAddressResolver = null;
     _identityClient = null;
     _paymentMuxes = new Map();
@@ -126,6 +140,7 @@ export class AntseedNode extends EventEmitter {
     _partialPeerEnrichmentChain = Promise.resolve();
     /** Serializes non-blocking external claim verification for discovered peers. */
     _externalVerificationChain = Promise.resolve();
+    _identityHistoryCollector;
     _externalVerificationCache = new Map();
     _externalVerificationInFlight = new Set();
     constructor(config) {
@@ -387,6 +402,7 @@ export class AntseedNode extends EventEmitter {
         this._buyerFreeUsageManager = null;
         this._sellerFreeUsageManager = null;
         this._stakingClient = null;
+        this._trustSignalsClient = null;
         this._identityClient = null;
         this._sellerAddressResolver = null;
         this._buyerPaymentManager = null;
@@ -482,12 +498,12 @@ export class AntseedNode extends EventEmitter {
         });
     }
     _queuePartialPeerEnrichment(peers) {
-        if (peers.length === 0 || !this._channelsClient || !this._stakingClient) {
+        if (peers.length === 0 || !this._trustSignalsClient) {
             return;
         }
-        const peersToEnrich = peers.map((peer) => ({ ...peer }));
+        const peersToEnrich = peers;
         this._partialPeerEnrichmentChain = this._partialPeerEnrichmentChain.then(async () => {
-            if (!this._started || !this._channelsClient || !this._stakingClient) {
+            if (!this._started || !this._trustSignalsClient) {
                 return;
             }
             await this._enrichPeersWithOnChainStats(peersToEnrich);
@@ -522,6 +538,8 @@ export class AntseedNode extends EventEmitter {
         const queued = [];
         const nowMs = Date.now();
         for (const peer of peers) {
+            if (this._externalVerificationInFlight.size >= 512)
+                break;
             const claimsKey = this._externalVerificationClaimsKey(peer);
             if (!claimsKey)
                 continue;
@@ -535,7 +553,7 @@ export class AntseedNode extends EventEmitter {
                 continue;
             }
             this._externalVerificationInFlight.add(cacheKey);
-            queued.push({ ...peer });
+            queued.push(peer);
         }
         if (queued.length === 0)
             return;
@@ -594,17 +612,19 @@ export class AntseedNode extends EventEmitter {
                 domains,
                 github,
             };
+            this._identityHistoryCollector ??= new IdentityHistoryCollector();
+            results.identityHistory = await this._identityHistoryCollector.collect(results);
+            if (this._externalVerificationCache.size >= 512) {
+                this._externalVerificationCache.delete(this._externalVerificationCache.keys().next().value);
+            }
             this._externalVerificationCache.set(peer.peerId, {
                 claimsKey,
                 checkedAtMs,
                 results,
             });
-            const verifiedPeer = { ...peer, verificationResults: results };
-            const risk = typeof verifiedPeer.onChainSybilRisk === 'number'
-                ? verifiedPeer.onChainSybilRisk
-                : 0;
-            verifiedPeer.onChainReputationScore = computeOnChainScoreWithRisk(verifiedPeer, risk) ?? verifiedPeer.onChainReputationScore;
-            return verifiedPeer;
+            peer.verificationResults = results;
+            applyTrust(peer);
+            return peer;
         }
         catch (err) {
             debugWarn(`[Node] External verification failed for ${peer.peerId.slice(0, 12)}...: ${err instanceof Error ? err.message : err}`);
@@ -635,7 +655,7 @@ export class AntseedNode extends EventEmitter {
      * enriches its results, so volume / last-settled / ghost counts are
      * available when chain RPC is configured.
      */
-    async findPeer(peerId) {
+    async findPeer(peerId, options) {
         if (!this._peerLookup) {
             throw buyerFault("Node not started or not in buyer mode", "node-not-started");
         }
@@ -659,7 +679,12 @@ export class AntseedNode extends EventEmitter {
         const best = results.reduce((acc, r) => r.metadata.timestamp > acc.metadata.timestamp ? r : acc);
         const peer = this._lookupResultToPeerInfo(best);
         this._attachCachedExternalVerificationResults([peer]);
-        this._queueExternalVerification([peer]);
+        if (options?.awaitExternalVerification && !peer.verificationResults && this._externalVerificationClaimsKey(peer)) {
+            await this._verifyExternalClaimsForPeer(peer);
+        }
+        else {
+            this._queueExternalVerification([peer]);
+        }
         await this._enrichPeersWithOnChainStats([peer]);
         return peer;
     }
@@ -676,81 +701,81 @@ export class AntseedNode extends EventEmitter {
      * configured — callers can safely invoke this regardless.
      */
     async _enrichPeersWithOnChainStats(peers) {
-        if (!this._channelsClient || !this._stakingClient || peers.length === 0) {
+        const client = this._trustSignalsClient;
+        if (!client || peers.length === 0) {
             return;
         }
-        const channelsClient = this._channelsClient;
-        const stakingClient = this._stakingClient;
         const resolver = this._sellerAddressResolver;
-        const DISCOVERY_RPC_CONCURRENCY = 8;
-        // Throttle on-chain reads across rapid discovery cycles. 60s is short
-        // enough that freshness feels real-time in the UI, and long enough that
-        // back-to-back `discoverPeers()` calls don't hammer the RPC endpoint.
-        const ON_CHAIN_STATS_TTL_MS = 60_000;
+        // Every stale peer is read in one batched pass (two Multicall3 round
+        // trips), so the refresh interval bounds RPC usage per discovery cycle
+        // instead of the peer count.
+        const ON_CHAIN_STATS_TTL_MS = 120_000;
         const nowMs = Date.now();
-        const queue = peers.slice();
         const peersWithCompleteStats = new Set();
-        const verifyOne = async (p) => {
-            if (typeof p.onChainStatsFetchedAt === 'number'
-                && nowMs - p.onChainStatsFetchedAt < ON_CHAIN_STATS_TTL_MS) {
+        const stale = [];
+        for (const p of peers) {
+            if (typeof p.onChainStatsFetchedAt === 'number' && nowMs - p.onChainStatsFetchedAt < ON_CHAIN_STATS_TTL_MS) {
                 peersWithCompleteStats.add(p);
-                return;
+                continue;
             }
             try {
-                const evmAddress = resolver
+                const address = resolver
                     ? await resolver.resolveSellerAddress(p.peerId, p.metadata)
                     : peerIdToAddress(p.peerId);
-                const [agentId, stake, stakedAt] = await Promise.all([
-                    stakingClient.getAgentId(evmAddress),
-                    stakingClient.getStake(evmAddress).catch(() => null),
-                    stakingClient.getStakedAt(evmAddress).catch(() => null),
-                ]);
-                const stats = await channelsClient.getAgentStats(agentId);
-                if (stake === null || stakedAt === null) {
-                    return;
-                }
-                p.onChainAgentId = agentId;
-                p.onChainStakeUsdcMicros = stake <= BigInt(Number.MAX_SAFE_INTEGER)
-                    ? Number(stake)
-                    : Number.MAX_SAFE_INTEGER;
-                p.onChainChannelCount = stats.channelCount;
-                p.onChainGhostCount = stats.ghostCount;
-                // totalVolumeUsdc is base-6 USDC. Clamp to safe-int range before
-                // narrowing to Number — ~9M USDC fits Number.MAX_SAFE_INTEGER.
-                const volumeMicros = stats.totalVolumeUsdc;
-                p.onChainTotalVolumeUsdcMicros = volumeMicros <= BigInt(Number.MAX_SAFE_INTEGER)
-                    ? Number(volumeMicros)
-                    : Number.MAX_SAFE_INTEGER;
-                p.onChainLastSettledAtSec = stats.lastSettledAt;
-                // Some migrated/facade staking accounts return zero for `stakedAt`,
-                // and transient RPC failures used to be coerced to zero as well. A
-                // zero read must not erase a previously verified positive timestamp.
-                if (typeof stakedAt === 'number' && Number.isFinite(stakedAt) && stakedAt > 0) {
-                    p.onChainStakedAtSec = stakedAt;
-                }
-                p.onChainStatsFetchedAt = Date.now();
-                peersWithCompleteStats.add(p);
+                stale.push({ peer: p, address });
             }
             catch {
-                // Per-peer verification failure — preserve the previous complete
-                // snapshot, or leave a newly discovered peer unenriched.
+                // Unresolvable seller address: leave the previous snapshot in place.
             }
-        };
-        const workers = [];
-        for (let i = 0; i < Math.min(DISCOVERY_RPC_CONCURRENCY, queue.length); i++) {
-            workers.push((async () => {
-                for (;;) {
-                    const next = queue.shift();
-                    if (!next)
-                        return;
-                    await verifyOne(next);
-                }
-            })());
         }
-        await Promise.all(workers);
-        this._applyTrustAndSybil(peers, peersWithCompleteStats);
-    }
-    _applyTrustAndSybil(peers, peersToUpdate) {
+        if (stale.length === 0) {
+            this._applyTrust(peers, peersWithCompleteStats);
+            return;
+        }
+        let signals;
+        try {
+            signals = await client.read(stale.map((entry) => entry.address));
+        }
+        catch (err) {
+            debugWarn(`[Node] On-chain trust signal read failed: ${err instanceof Error ? err.message : err}`);
+            this._applyTrust(peers, peersWithCompleteStats);
+            return;
+        }
+        for (const { peer: p, address } of stale) {
+            const read = signals.get(address);
+            // A peer without an agent id (or a failed batch entry) keeps its
+            // previous complete snapshot, or stays unenriched when newly discovered.
+            if (!read)
+                continue;
+            p.onChainAgentId = read.agentId;
+            if (read.channelCount !== undefined)
+                p.onChainChannelCount = read.channelCount;
+            if (read.ghostCount !== undefined)
+                p.onChainGhostCount = read.ghostCount;
+            if (read.totalVolumeUsdcMicros !== undefined)
+                p.onChainTotalVolumeUsdcMicros = read.totalVolumeUsdcMicros;
+            if (read.lastSettledAtSec !== undefined)
+                p.onChainLastSettledAtSec = read.lastSettledAtSec;
+            if (read.usageEpoch !== undefined) {
+                p.onChainUsageEpoch = read.usageEpoch;
+                p.onChainUsageShareBps = read.usageShareBps;
+                p.onChainUsageLastEpochUsdcMicros = read.usageLastEpochUsdcMicros;
+            }
+            if (read.poolStakeAnts !== undefined)
+                p.onChainPoolStakeAnts = read.poolStakeAnts;
+            if (read.poolPowerShareBps !== undefined)
+                p.onChainPoolPowerShareBps = read.poolPowerShareBps;
+            if (read.washFlagged !== undefined)
+                p.onChainWashFlagged = read.washFlagged;
+            if (read.washShareBps !== undefined)
+                p.onChainWashShareBps = read.washShareBps;
+            p.onChainStatsFetchedAt = Date.now();
+            peersWithCompleteStats.add(p);
+        }
+        this._applyTrust(peers, peersWithCompleteStats);
+    }
+    /** Recompute the trust score and the display-only sybil heuristic. */
+    _applyTrust(peers, peersToUpdate) {
         if (peers.length === 0)
             return;
         const ctx = peers.length >= 2
@@ -759,16 +784,12 @@ export class AntseedNode extends EventEmitter {
         for (const p of peers) {
             if (peersToUpdate && !peersToUpdate.has(p))
                 continue;
-            const trust = computeOnChainTrust(p);
-            if (trust === null)
-                continue;
-            p.onChainTrustScore = trust;
-            if (ctx) {
+            if (ctx && typeof p.onChainChannelCount === 'number') {
                 const sybil = computeOnChainSybilRisk(p, ctx);
                 p.onChainSybilRisk = sybil.risk;
                 p.onChainSybilFlags = sybil.flags;
             }
-            p.onChainReputationScore = computeOnChainScore(p, ctx) ?? undefined;
+            applyTrust(p);
         }
     }
     /**
@@ -1620,6 +1641,16 @@ export class AntseedNode extends EventEmitter {
             });
             debugLog(`[Node] StakingClient initialized (contract=${payments.stakingAddress.slice(0, 10)}...)`);
         }
+        if (this._channelsClient && payments.stakingAddress && payments.channelsAddress) {
+            this._trustSignalsClient = new TrustSignalsClient(this._channelsClient.provider, {
+                sellerRegistry: payments.stakingAddress,
+                channels: payments.channelsAddress,
+                ...(payments.sellerPoolsAddress ? { sellerPools: payments.sellerPoolsAddress } : {}),
+                ...(payments.usageAccountingAddress ? { usageAccounting: payments.usageAccountingAddress } : {}),
+                ...(payments.washTradingRegistryAddress ? { washTradingRegistry: payments.washTradingRegistryAddress } : {}),
+            });
+            debugLog(`[Node] TrustSignalsClient initialized (pools=${Boolean(payments.sellerPoolsAddress)} usage=${Boolean(payments.usageAccountingAddress)} wash=${Boolean(payments.washTradingRegistryAddress)})`);
+        }
         // Initialize IdentityClient (ERC-8004 IdentityRegistry)
         if (payments.rpcUrl && payments.identityRegistryAddress) {
             this._identityClient = new IdentityClient({
@@ -1946,6 +1977,7 @@ export class AntseedNode extends EventEmitter {
         return `${result.host}:${result.port}`;
     }
     _lookupResultToPeerInfo(result) {
+        const displayName = sanitizePeerDisplayName(result.metadata.displayName);
         const providers = result.metadata.providers.map((p) => p.provider);
         const firstProvider = result.metadata.providers[0];
         const providerPricingEntries = {};
@@ -2030,7 +2062,7 @@ export class AntseedNode extends EventEmitter {
         const hasProviderServiceCapabilities = Object.keys(providerServiceCapabilityEntries).length > 0;
         return {
             peerId: result.metadata.peerId,
-            displayName: result.metadata.displayName,
+            displayName,
             // `metadata.timestamp` is signed by the seller and can reflect the
             // seller's wall clock, not this buyer's. Freshness validation in
             // PeerLookup already handles seller/buyer clock skew using the HTTP Date