@antseed/node 0.2.152 → 0.2.154

package/dist/node.js

@@ -6,6 +6,7 @@ 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 { isFreeUnitBillingModel } from "./billing/unit.js";
 import { MeteringStorage } from "./metering/storage.js";
 import { ResourceOwnershipStore } from "./resources/resource-ownership-store.js";
 import { ReceiptGenerator } from "./metering/receipt-generator.js";
@@ -14,7 +15,7 @@ import { ConnectionState } from "./types/connection.js";
 import { DHTNode, DEFAULT_DHT_CONFIG, SUBNET_COUNT, } from "./discovery/dht-node.js";
 import { toBootstrapConfig, OFFICIAL_BOOTSTRAP_NODES, mergeBootstrapNodes } from "./discovery/bootstrap.js";
 import { ConnectionManager, } from "./p2p/connection-manager.js";
-import { PeerAnnouncer, } from "./discovery/announcer.js";
+import { PeerAnnouncer, builtinPeerCapabilities, } from "./discovery/announcer.js";
 import { verifyPeerMetadataDomains } from "./discovery/domain-verification.js";
 import { verifyPeerMetadataGithub } from "./discovery/github-verification.js";
 import { PeerLookup, DEFAULT_LOOKUP_CONFIG, } from "./discovery/peer-lookup.js";
@@ -36,11 +37,15 @@ import { signUtf8 } from "./p2p/identity.js";
 import { BalanceManager, DepositsClient, ChannelsClient, FreeUsageClient, BuyerFreeUsageManager, SellerFreeUsageManager, SellerFreeTierLimiter, 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 { MAX_PEER_CAPABILITIES } from "./discovery/metadata-validator.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";
 import { SellerAddressResolver } from "./discovery/seller-address-resolver.js";
+import { SellerPoolsClient } from "./payments/evm/seller-pools-client.js";
+import { FreeTierStakeResolver } from "./payments/free-tier-stake-resolver.js";
+import { encodeFreeTierDelegationsHeader } from "./payments/free-tier-delegation.js";
 import { Contract as EthersContract } from "ethers";
 import { SellerPaymentManager } from "./payments/seller-payment-manager.js";
 import { IdentityClient } from "./payments/evm/identity-client.js";
@@ -154,6 +159,8 @@ export class AntseedNode extends EventEmitter {
     _buyerIdentities = new Map();
     /** Seller-side deposit-sweep relayer (initialized when configured + enabled). */
     _depositRelayer = null;
+    /** Settles or closes a buyer's channel when its metering session goes idle; removed on stop. */
+    _settleOnIdle = null;
     /** Seller-side request handler (provider matching, execution, load tracking). */
     _sellerHandler = null;
     /** Buyer-side payment manager (initialized when buyer has payment config). */
@@ -328,7 +335,7 @@ export class AntseedNode extends EventEmitter {
         }
         const dataDir = this._config.dataDir ?? join(homedir(), ".antseed");
         // Load or create identity
-        this._identity = await loadOrCreateIdentity(this._config.identityStore ?? dataDir);
+        this._identity = this._config.identity ?? await loadOrCreateIdentity(this._config.identityStore ?? dataDir);
         debugLog(`[Node] Identity loaded: ${this._identity.peerId.slice(0, 12)}...`);
         // Determine bootstrap nodes — merge official + any user-configured nodes unless
         // noOfficialBootstrap is set (e.g. isolated local testing).
@@ -336,11 +343,22 @@ export class AntseedNode extends EventEmitter {
             ? (this._config.bootstrapNodes ?? [])
             : mergeBootstrapNodes(OFFICIAL_BOOTSTRAP_NODES, this._config.bootstrapNodes ?? []));
         debugLog(`[Node] Starting as ${this._config.role} with ${bootstrapNodes.length} bootstrap node(s)`);
-        if (this._config.role === "seller") {
-            await this._startSeller(bootstrapNodes);
+        try {
+            if (this._config.role === "seller") {
+                await this._startSeller(bootstrapNodes);
+            }
+            else {
+                await this._startBuyer(bootstrapNodes);
+            }
         }
-        else {
-            await this._startBuyer(bootstrapNodes);
+        catch (error) {
+            // A start that fails partway (say the DHT after the payment store and
+            // RPC monitor) releases what it opened, so a retry starts clean.
+            this._started = true;
+            await this.stop().catch((err) => {
+                debugWarn(`[Node] Cleanup after a failed start failed: ${err instanceof Error ? err.message : err}`);
+            });
+            throw error;
         }
         this._started = true;
         debugLog(`[Node] Started successfully`);
@@ -485,6 +503,12 @@ export class AntseedNode extends EventEmitter {
         this._buyerHandler = null;
         this._backgroundPeerDiscoveryPromise = null;
         this._sellerPaymentManager = null;
+        if (this._settleOnIdle) {
+            this.off("session:finalized", this._settleOnIdle);
+            this._settleOnIdle = null;
+        }
+        this._depositRelayer = null;
+        this._advertisingPausedReason = null;
         this._sessionTracker = null;
         this._started = false;
         this.emit("stopped");
@@ -1231,6 +1255,7 @@ export class AntseedNode extends EventEmitter {
             },
             maxUploadBodyBytes: this._config.maxUploadBodyBytes,
             requireSecureTransport: this._config.requireSecureTransport,
+            freeTierDelegationsHeader: () => this._freeTierDelegationsHeader(identity.wallet.address),
             shared: {
                 channelStore: this._channelStore,
                 depositsClient: this._depositsClient,
@@ -1454,12 +1479,16 @@ export class AntseedNode extends EventEmitter {
         this._sellerFreeTierLimiter = this._config.freeTier
             ? new SellerFreeTierLimiter(this._config.freeTier, this._metering)
             : null;
+        const offered = this._offeredServicesByPrice();
+        this._sellerFreeTierLimiter?.setPaidServices(offered.paid);
+        this._sellerFreeTierLimiter?.setFreeServices(offered.free);
         await this._initializePayments(dataDir);
         this._warnIfFreeUsageMeteringUnavailable();
+        this._initializeFreeTierStakeResolver(identity);
         // Wire idle session events to on-chain settlement
         if (this._sellerPaymentManager) {
             const spm = this._sellerPaymentManager;
-            this.on("session:finalized", (info) => {
+            this._settleOnIdle = (info) => {
                 if (info.reason === "idle-settle") {
                     debugLog(`[Node] Idle settle for buyer ${info.buyerPeerId.slice(0, 12)}... — settling channel (keeping open)`);
                     void spm.settleSession(info.buyerPeerId, { settleOnly: true });
@@ -1468,7 +1497,8 @@ export class AntseedNode extends EventEmitter {
                     debugLog(`[Node] Idle timeout for buyer ${info.buyerPeerId.slice(0, 12)}... — closing channel`);
                     void spm.settleSession(info.buyerPeerId, { cleanupOnFailure: true });
                 }
-            });
+            };
+            this.on("session:finalized", this._settleOnIdle);
         }
         // Start DHT
         this._dht = new DHTNode(this._createDHTConfig(dhtPort, bootstrapNodes));
@@ -1506,10 +1536,12 @@ export class AntseedNode extends EventEmitter {
         }
         // Set up announcer for providers
         if (this._providers.length > 0) {
-            const extraCapabilities = [
+            const baseCapabilities = [
                 ...(this._connectionManager.supportsWebRtc ? [CONNECTION_CAPABILITY_WEBRTC_V1] : []),
                 ...(this._config.capabilities ?? []),
             ];
+            const usedCapabilities = builtinPeerCapabilities(this._depositRelayer !== null).length + baseCapabilities.length;
+            const extraCapabilities = [...baseCapabilities, ...this._freeTierCapabilities(usedCapabilities)];
             const announcerConfig = {
                 identity,
                 dht: this._dht,
@@ -1666,6 +1698,7 @@ export class AntseedNode extends EventEmitter {
             getMux: (peerId, conn) => this._getOrCreateMux(peerId, conn),
             getVerificationMux: (peerId, conn) => this._getOrCreateVerificationMux(peerId, conn),
             registerPaymentMux: (peerId, pmux) => this._paymentMuxes.set(peerId, pmux),
+            freeTierDelegationsHeader: () => this._freeTierDelegationsHeader(identity.wallet.address),
         });
         debugLog(`[Node] Buyer ready — DHT running on port ${this._dht.getPort()}`);
     }
@@ -1841,7 +1874,7 @@ export class AntseedNode extends EventEmitter {
                         sellerContracts.set(sellerContract, contract);
                     }
                     else {
-                        contract = new EthersContract(sellerContract, isOperatorAbi, channelsClientRef.provider);
+                        contract = new EthersContract(sellerContract, isOperatorAbi, payments.readProvider ?? channelsClientRef.provider);
                         if (sellerContracts.size >= SELLER_CONTRACTS_MAX) {
                             const oldest = sellerContracts.keys().next().value;
                             if (oldest !== undefined)
@@ -1894,7 +1927,7 @@ 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, {
+            this._trustSignalsClient = new TrustSignalsClient(payments.readProvider ?? this._channelsClient.provider, {
                 sellerRegistry: payments.stakingAddress,
                 channels: payments.channelsAddress,
                 ...(payments.sellerPoolsAddress ? { sellerPools: payments.sellerPoolsAddress } : {}),
@@ -2294,6 +2327,84 @@ export class AntseedNode extends EventEmitter {
             onChainGhostCount: result.metadata.onChainGhostCount,
         };
     }
+    /** Replace the buyer's free-tier delegations; later requests send the new set. */
+    setFreeTierDelegations(delegations) {
+        this._config.freeTierDelegations = [...delegations];
+    }
+    /** Header value carrying the unexpired delegations to `buyerAddress`, or null when there are none. */
+    _freeTierDelegationsHeader(buyerAddress) {
+        const nowSeconds = Date.now() / 1000;
+        const delegations = (this._config.freeTierDelegations ?? []).filter((delegation) => delegation.buyer.toLowerCase() === buyerAddress.toLowerCase() && delegation.expiresAt > nowSeconds);
+        return delegations.length > 0 ? encodeFreeTierDelegationsHeader(delegations) : null;
+    }
+    /**
+     * Back staked free-tier tiers with on-chain reads: the positions of the
+     * buyer and of every staker that signed a delegation to it in this seller's
+     * pool. Without the seller pools contract every buyer keeps the base limits
+     * and no tiers are advertised.
+     */
+    /**
+     * Free-tier programs to advertise within what is left of the peer
+     * capability limit. Programs that do not fit are still enforced; buyers
+     * learn them from the seller's refusals instead.
+     */
+    /**
+     * Offered services by whether some provider charges for them (tokens or any
+     * priced unit-billing model), as the request handler decides it. A paid
+     * service's allowance never admits a free-usage channel; the free ones decide admission.
+     */
+    _offeredServicesByPrice() {
+        const paid = new Set();
+        const offered = new Set();
+        for (const provider of this._providers) {
+            for (const service of provider.services) {
+                offered.add(service);
+                const pricing = provider.pricing.services?.[service] ?? provider.pricing.defaults;
+                const tokenPriced = pricing.inputUsdPerMillion > 0 || pricing.outputUsdPerMillion > 0 || (pricing.cachedInputUsdPerMillion ?? 0) > 0;
+                const unitPriced = Object.values(provider.serviceUnitBillingModels?.[service] ?? {})
+                    .some((model) => model !== undefined && !isFreeUnitBillingModel(model));
+                if (tokenPriced || unitPriced)
+                    paid.add(service);
+            }
+        }
+        return { paid: [...paid], free: [...offered].filter((service) => !paid.has(service)) };
+    }
+    _freeTierCapabilities(usedCapabilities) {
+        const limiter = this._sellerFreeTierLimiter;
+        if (!limiter)
+            return [];
+        const capabilities = limiter.capabilities(MAX_PEER_CAPABILITIES - usedCapabilities);
+        if (capabilities.length < limiter.capabilities().length) {
+            debugWarn(`[Node] Not every free-tier program fits in peer metadata (${MAX_PEER_CAPABILITIES} capabilities max); ` +
+                `the rest are enforced but not advertised`);
+        }
+        return capabilities;
+    }
+    _initializeFreeTierStakeResolver(identity) {
+        const limiter = this._sellerFreeTierLimiter;
+        const payments = this._config.payments;
+        if (!limiter || !limiter.hasStakeTiers)
+            return;
+        if (!payments?.rpcUrl || !payments.sellerPoolsAddress) {
+            debugLog("[Node] Staked free-tier tiers disabled: seller pools contract not configured");
+            return;
+        }
+        const sellerPools = new SellerPoolsClient({
+            rpcUrl: payments.rpcUrl,
+            ...(payments.fallbackRpcUrls ? { fallbackRpcUrls: payments.fallbackRpcUrls } : {}),
+            contractAddress: payments.sellerPoolsAddress,
+            // Only stake writes use the token; the free tier only reads.
+            antsTokenAddress: "0x0000000000000000000000000000000000000000",
+            ...(payments.chainId ? { evmChainId: payments.chainId } : {}),
+        });
+        const sellerAddress = this._config.sellerContract?.sellerContract ?? identity.wallet.address;
+        limiter.setStakeResolver(new FreeTierStakeResolver({
+            sellerAgentId: () => sellerPools.agentIdForSeller(sellerAddress),
+            currentEpoch: () => sellerPools.currentEpoch(),
+            stakerPositions: (staker, agentId, epoch) => sellerPools.stakerPositionsInPool(staker, agentId, epoch),
+        }), payments.chainId ?? 8453);
+        debugLog(`[Node] Staked free-tier tiers enabled (pools=${payments.sellerPoolsAddress.slice(0, 10)}...)`);
+    }
     _warnIfFreeUsageMeteringUnavailable() {
         if (this._sellerFreeUsageManager || !this._hasFreePricedService())
             return;