@antseed/node 0.2.26 → 0.2.28

package/dist/node.js

@@ -1,11 +1,11 @@
 import { EventEmitter } from "node:events";
-import { createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadOrCreateIdentity } from "./p2p/identity.js";
-import { ANTSEED_STREAMING_RESPONSE_HEADER, } from "./types/http.js";
+import { peerIdToAddress } from "./types/peer.js";
 import { MeteringStorage } from "./metering/storage.js";
 import { ReceiptGenerator } from "./metering/receipt-generator.js";
+import { SellerSessionTracker, } from "./metering/seller-session-tracker.js";
 import { ConnectionState } from "./types/connection.js";
 import { DHTNode, DEFAULT_DHT_CONFIG, } from "./discovery/dht-node.js";
 import { toBootstrapConfig, OFFICIAL_BOOTSTRAP_NODES, mergeBootstrapNodes } from "./discovery/bootstrap.js";
@@ -19,16 +19,17 @@ import { FrameDecoder, encodeFrame } from "./p2p/message-protocol.js";
 import { KeepaliveManager, buildPongPayload } from "./p2p/keepalive.js";
 import { MessageType } from "./types/protocol.js";
 import { NatTraversal } from "./p2p/nat-traversal.js";
-import { signUtf8Ed25519 } from "./p2p/identity.js";
-import { verifyMessage, getBytes } from "ethers";
-import { BalanceManager, BaseEscrowClient, identityToEvmWallet, buildLockMessageHash, buildReceiptMessage, buildAckMessage, signMessageEd25519, verifyMessageEd25519, } from "./payments/index.js";
-import { hexToBytes, bytesToHex } from "./utils/hex.js";
+import { signUtf8 } from "./p2p/identity.js";
+import { BalanceManager, DepositsClient, ChannelsClient, StakingClient, ChannelStore, } from "./payments/index.js";
 import { debugLog, debugWarn } from "./utils/debug.js";
 import { parsePublicAddress } from "./discovery/public-address.js";
 import { BuyerPaymentManager } from "./payments/buyer-payment-manager.js";
-import { identityToEvmAddress } from "./payments/evm/keypair.js";
+import { BuyerPaymentNegotiator } from "./payments/buyer-payment-negotiator.js";
+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";
 export class AntseedNode extends EventEmitter {
-    static _METADATA_REFRESH_DEBOUNCE_MS = 200;
     _config;
     _identity = null;
     _dht = null;
@@ -45,17 +46,29 @@ export class AntseedNode extends EventEmitter {
     _metering = null;
     _receiptGenerator = null;
     _balanceManager = null;
-    _escrowClient = null;
+    _depositsClient = null;
+    _channelsClient = null;
+    _stakingClient = null;
+    _identityClient = null;
     _paymentMuxes = new Map();
-    _providerLoadCounts = new Map();
-    _metadataRefreshTimer = null;
-    /** Per-buyer session tracking: buyerPeerId → seller session state */
-    _sessions = new Map();
-    _settlementTimers = new Map();
+    /** Seller-side request handler (provider matching, execution, load tracking). */
+    _sellerHandler = null;
     /** Buyer-side payment manager (initialized when buyer has payment config). */
     _buyerPaymentManager = null;
-    /** Tracks which seller peers the buyer has already initiated a lock for. */
-    _buyerLockedPeers = new Set();
+    /** Buyer-side payment negotiation (402 handling, SpendingAuth, cost tracking). */
+    _buyerNegotiator = null;
+    /** Buyer-side request execution (streaming, timeouts, 402 retry). */
+    _buyerHandler = null;
+    /** Seller-side payment manager (initialized when seller has payment config). */
+    _sellerPaymentManager = null;
+    /** Shared channel store for payment persistence. */
+    _channelStore = null;
+    /** Periodic timeout checker interval. */
+    _timeoutCheckerInterval = null;
+    /** Block cursor for CloseRequested event polling. */
+    _closeRequestedFromBlock = 0;
+    /** Seller session lifecycle tracking (metering, settlement). */
+    _sessionTracker = null;
     constructor(config) {
         super();
         this._config = config;
@@ -79,6 +92,10 @@ export class AntseedNode extends EventEmitter {
     get buyerPaymentManager() {
         return this._buyerPaymentManager;
     }
+    /** Buyer-side payment negotiator (null if payments not configured for buyer). */
+    get buyerNegotiator() {
+        return this._buyerNegotiator;
+    }
     /** Actual DHT port after binding (0 means not started). */
     get dhtPort() {
         return this._dht?.getPort() ?? 0;
@@ -87,6 +104,10 @@ export class AntseedNode extends EventEmitter {
     get signalingPort() {
         return this._connectionManager?.getListeningPort() ?? 0;
     }
+    /** ERC-8004 IdentityRegistry client (null if not configured). */
+    get identityClient() {
+        return this._identityClient;
+    }
     /** Current connection state for a peer if a connection exists, otherwise null. */
     getPeerConnectionState(peerId) {
         return this._connectionManager?.getConnection(peerId)?.state ?? null;
@@ -96,35 +117,11 @@ export class AntseedNode extends EventEmitter {
      * Includes open sessions before they are finalized/settled.
      */
     getActiveSellerSessions() {
-        const snapshots = [];
-        for (const [buyerPeerId, session] of this._sessions.entries()) {
-            snapshots.push({
-                sessionId: session.sessionId,
-                buyerPeerId,
-                provider: session.provider,
-                startedAt: session.startedAt,
-                lastActivityAt: session.lastActivityAt,
-                totalRequests: session.totalRequests,
-                totalTokens: session.totalTokens,
-                avgLatencyMs: session.totalRequests > 0 ? session.totalLatencyMs / session.totalRequests : 0,
-                settling: Boolean(session.settling),
-                lockCommitted: session.lockCommitted,
-                lockedAmountUSDC: session.lockedAmount.toString(),
-                runningTotalUSDC: session.runningTotal.toString(),
-                ackedRequestCount: session.ackedRequestCount,
-            });
-        }
-        return snapshots;
+        return this._sessionTracker?.getActiveSessions() ?? [];
     }
-    /** Number of active in-memory seller sessions that are not currently settling. */
-    getActiveSellerSessionCount() {
-        let count = 0;
-        for (const session of this._sessions.values()) {
-            if (!session.settling) {
-                count += 1;
-            }
-        }
-        return count;
+    /** Number of active in-memory seller channels that are not currently settling. */
+    getActiveSellerChannelCount() {
+        return this._sessionTracker?.getActiveChannelCount() ?? 0;
     }
     async start() {
         if (this._started) {
@@ -132,7 +129,7 @@ export class AntseedNode extends EventEmitter {
         }
         const dataDir = this._config.dataDir ?? join(homedir(), ".antseed");
         // Load or create identity
-        this._identity = await loadOrCreateIdentity(dataDir);
+        this._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).
@@ -155,17 +152,17 @@ export class AntseedNode extends EventEmitter {
             return;
         }
         // End all active buyer payment sessions before shutdown
-        await this._endAllBuyerSessions();
-        await this._finalizeAllSessions("node-stop");
-        for (const timer of this._settlementTimers.values()) {
-            clearTimeout(timer);
+        if (this._buyerNegotiator) {
+            this._buyerNegotiator.cleanup();
         }
-        this._settlementTimers.clear();
-        if (this._metadataRefreshTimer) {
-            clearTimeout(this._metadataRefreshTimer);
-            this._metadataRefreshTimer = null;
+        if (this._sessionTracker) {
+            await this._sessionTracker.finalizeAllSessions("node-stop");
+            this._sessionTracker.clearTimers();
+        }
+        if (this._sellerHandler) {
+            this._sellerHandler.clearMetadataRefreshTimer();
+            this._sellerHandler = null;
         }
-        this._providerLoadCounts.clear();
         // Remove NAT port mappings
         if (this._nat) {
             await this._nat.cleanup();
@@ -213,12 +210,31 @@ export class AntseedNode extends EventEmitter {
             }
             this._metering = null;
         }
+        if (this._timeoutCheckerInterval) {
+            clearInterval(this._timeoutCheckerInterval);
+            this._timeoutCheckerInterval = null;
+        }
+        if (this._channelStore) {
+            try {
+                this._channelStore.close();
+            }
+            catch {
+                // ignore close errors
+            }
+            this._channelStore = null;
+        }
         this._peerLookup = null;
         this._receiptGenerator = null;
         this._balanceManager = null;
-        this._escrowClient = null;
+        this._depositsClient = null;
+        this._channelsClient = null;
+        this._stakingClient = null;
+        this._identityClient = null;
         this._buyerPaymentManager = null;
-        this._buyerLockedPeers.clear();
+        this._buyerNegotiator = null;
+        this._buyerHandler = null;
+        this._sellerPaymentManager = null;
+        this._sessionTracker = null;
         this._started = false;
         this.emit("stopped");
     }
@@ -247,20 +263,18 @@ export class AntseedNode extends EventEmitter {
                 peers.push(p);
             }
         }
-        // Optional reputation verification: replace claimed data with verified on-chain data
-        if (this._escrowClient) {
+        // Verify claimed on-chain stats against actual contract data
+        if (this._channelsClient && this._stakingClient) {
             for (const p of peers) {
-                if (p.evmAddress && p.onChainReputation !== undefined) {
-                    try {
-                        const rep = await this._escrowClient.getReputation(p.evmAddress);
-                        p.onChainReputation = rep.weightedAverage;
-                        p.onChainSessionCount = rep.sessionCount;
-                        p.onChainDisputeCount = rep.disputeCount;
-                        p.trustScore = rep.weightedAverage;
-                    }
-                    catch {
-                        // Use claimed data if verification fails
-                    }
+                try {
+                    const evmAddress = peerIdToAddress(p.peerId);
+                    const agentId = await this._stakingClient.getAgentId(evmAddress);
+                    const stats = await this._channelsClient.getAgentStats(agentId);
+                    p.onChainChannelCount = stats.channelCount;
+                    p.onChainGhostCount = stats.ghostCount;
+                }
+                catch {
+                    // Contract lookup failed for this peer — keep claimed data
                 }
             }
         }
@@ -276,203 +290,64 @@ export class AntseedNode extends EventEmitter {
     async connectToPeer(peer) {
         const conn = await this._getOrCreateConnection(peer);
         this._getOrCreateMux(peer.peerId, conn);
+        const negotiator = this._buyerNegotiator;
+        if (negotiator) {
+            this._paymentMuxes.set(peer.peerId, negotiator.getOrCreatePaymentMux(peer.peerId, conn));
+        }
+    }
+    /**
+     * Query session stats for a specific seller peer.
+     * Combines channel store data (authoritative payment/session info) with
+     * metering events when available.
+     */
+    getMeteringStatsByPeer(sellerPeerId) {
+        const buyerAddress = this._identity?.wallet.address ?? null;
+        const channel = (buyerAddress != null)
+            ? (this._channelStore?.getActiveChannelByPeerAndBuyer(sellerPeerId, 'buyer', buyerAddress)
+                ?? this._channelStore?.getLatestChannelByPeerAndBuyer(sellerPeerId, 'buyer', buyerAddress))
+            : (this._channelStore?.getActiveChannelByPeer(sellerPeerId, 'buyer')
+                ?? this._channelStore?.getLatestChannel(sellerPeerId, 'buyer'))
+                ?? null;
+        const lifetime = (buyerAddress != null)
+            ? this._channelStore?.getTotalsByPeerAndBuyer(sellerPeerId, 'buyer', buyerAddress)
+            : this._channelStore?.getTotalsByPeer(sellerPeerId, 'buyer')
+                ?? null;
+        if (!channel && !lifetime)
+            return null;
+        const liveTotals = this._buyerPaymentManager?.getResponseTokenTotals(sellerPeerId);
+        const inputTokens = (liveTotals != null) ? liveTotals.input
+            : (channel != null) ? Number(channel.tokensDelivered || '0')
+                : 0;
+        const outputTokens = (liveTotals != null) ? liveTotals.output
+            : (channel != null) ? Number(channel.previousConsumption || '0')
+                : 0;
+        return {
+            totalRequests: channel?.requestCount ?? 0,
+            inputTokens,
+            outputTokens,
+            totalTokens: inputTokens + outputTokens,
+            reservedUsdc: this._buyerPaymentManager?.getReserveCeiling(sellerPeerId)?.toString() ?? null,
+            consumedUsdc: channel?.authMax ?? null,
+            channelStatus: channel?.status ?? null,
+            reservedAt: channel?.reservedAt ?? null,
+            lifetimeSessions: lifetime?.totalSessions ?? 0,
+            lifetimeRequests: lifetime?.totalRequests ?? 0,
+            lifetimeInputTokens: lifetime?.totalInputTokens ?? 0,
+            lifetimeOutputTokens: lifetime?.totalOutputTokens ?? 0,
+            lifetimeTotalTokens: (lifetime?.totalInputTokens ?? 0) + (lifetime?.totalOutputTokens ?? 0),
+            lifetimeAuthorizedUsdc: (lifetime?.totalAuthorizedUsdc ?? 0n).toString(),
+            lifetimeFirstSessionAt: lifetime?.firstSessionAt ?? null,
+        };
     }
     async sendRequest(peer, req, options) {
-        return this._sendRequestInternal(peer, req, undefined, options);
+        if (!this._buyerHandler)
+            throw new Error("Node not started or not in buyer mode");
+        return this._buyerHandler.sendRequest(peer, req, undefined, options);
     }
     async sendRequestStream(peer, req, callbacks, options) {
-        return this._sendRequestInternal(peer, req, callbacks, options);
-    }
-    async _sendRequestInternal(peer, req, callbacks, options) {
-        if (!req.requestId || typeof req.requestId !== "string") {
-            throw new Error("requestId must be a non-empty string");
-        }
-        if (!this._connectionManager || !this._identity) {
-            throw new Error("Node not started");
-        }
-        const opName = callbacks ? "sendRequestStream" : "sendRequest";
-        debugLog(`[Node] ${opName} ${req.method} ${req.path} → peer ${peer.peerId.slice(0, 12)}... (reqId=${req.requestId.slice(0, 8)})`);
-        const conn = await this._getOrCreateConnection(peer);
-        debugLog(`[Node] Connection to ${peer.peerId.slice(0, 12)}... state=${conn.state}`);
-        const mux = this._getOrCreateMux(peer.peerId, conn);
-        // Buyer-side: initiate lock and wait for confirmation on first request to a new peer
-        if (this._buyerPaymentManager && !this._buyerLockedPeers.has(peer.peerId)) {
-            await this._initiateBuyerLock(peer, conn);
-        }
-        const startTime = Date.now();
-        return new Promise((resolve, reject) => {
-            const timeoutMs = this._config.requestTimeoutMs ?? 30_000;
-            const maxStreamBufferBytes = Math.max(1, this._config.maxStreamBufferBytes ?? 16 * 1024 * 1024);
-            const maxStreamDurationMs = Math.max(1, this._config.maxStreamDurationMs ?? 5 * 60_000);
-            const streamInitialResponseTimeoutMs = callbacks ? Math.max(timeoutMs, 90_000) : timeoutMs;
-            // Idle timeout for streaming: resets on each chunk so long-running
-            // streams (thinking models, large outputs) stay alive as long as
-            // data keeps flowing.
-            const streamIdleTimeoutMs = Math.max(timeoutMs, 60_000);
-            let settled = false;
-            let streamStarted = false;
-            let streamStartedAtMs = 0;
-            let streamBufferedBytes = 0;
-            let streamStartResponse = null;
-            const streamChunks = [];
-            let activeTimeout = null;
-            let activeTimeoutMs = streamInitialResponseTimeoutMs;
-            const abortSignal = options?.signal;
-            let abortListenerAttached = false;
-            let connectionStateListenerAttached = false;
-            const hasConnectionStateEvents = typeof conn.on === "function"
-                && typeof conn.off === "function";
-            const cleanupAbortListener = () => {
-                if (abortSignal && abortListenerAttached) {
-                    abortSignal.removeEventListener("abort", onAbort);
-                    abortListenerAttached = false;
-                }
-            };
-            const cleanupConnectionListener = () => {
-                if (!connectionStateListenerAttached)
-                    return;
-                conn.off("stateChange", onConnectionStateChange);
-                connectionStateListenerAttached = false;
-            };
-            const onConnectionStateChange = (state) => {
-                if (settled)
-                    return;
-                if (state !== ConnectionState.Closed && state !== ConnectionState.Failed) {
-                    return;
-                }
-                settled = true;
-                if (activeTimeout)
-                    clearTimeout(activeTimeout);
-                cleanupAbortListener();
-                cleanupConnectionListener();
-                mux.cancelProxyRequest(req.requestId);
-                reject(new Error(`Connection to ${peer.peerId} ${state.toLowerCase()} during request ${req.requestId}`));
-            };
-            const onAbort = () => {
-                if (settled)
-                    return;
-                settled = true;
-                if (activeTimeout)
-                    clearTimeout(activeTimeout);
-                cleanupAbortListener();
-                cleanupConnectionListener();
-                debugWarn(`[Node] Request ${req.requestId.slice(0, 8)} aborted by caller`);
-                mux.cancelProxyRequest(req.requestId);
-                reject(new Error(`Request ${req.requestId} aborted`));
-            };
-            if (abortSignal) {
-                if (abortSignal.aborted) {
-                    onAbort();
-                    return;
-                }
-                abortSignal.addEventListener("abort", onAbort, { once: true });
-                abortListenerAttached = true;
-            }
-            if (hasConnectionStateEvents) {
-                conn.on("stateChange", onConnectionStateChange);
-                connectionStateListenerAttached = true;
-            }
-            const resetTimeout = (ms) => {
-                if (activeTimeout)
-                    clearTimeout(activeTimeout);
-                activeTimeoutMs = ms;
-                activeTimeout = setTimeout(() => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    cleanupAbortListener();
-                    cleanupConnectionListener();
-                    debugWarn(`[Node] Request ${req.requestId.slice(0, 8)} timed out after ${Date.now() - startTime}ms `
-                        + `(timeout=${activeTimeoutMs}ms, stream=${callbacks ? "true" : "false"}, streamStarted=${streamStarted ? "true" : "false"}, buffered=${streamBufferedBytes}b)`);
-                    mux.cancelProxyRequest(req.requestId);
-                    reject(new Error(`Request ${req.requestId} timed out`));
-                }, ms);
-            };
-            // Initial timeout: wait for the first response frame.
-            resetTimeout(streamInitialResponseTimeoutMs);
-            const finish = (response) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (activeTimeout)
-                    clearTimeout(activeTimeout);
-                cleanupAbortListener();
-                cleanupConnectionListener();
-                const cleaned = this._stripStreamingHeader(response);
-                debugLog(`[Node] Response for ${req.requestId.slice(0, 8)}: status=${cleaned.statusCode} (${Date.now() - startTime}ms, ${cleaned.body.length}b)`);
-                resolve(cleaned);
-            };
-            const fail = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (activeTimeout)
-                    clearTimeout(activeTimeout);
-                cleanupAbortListener();
-                cleanupConnectionListener();
-                reject(error);
-            };
-            mux.sendProxyRequest(req, (response, metadata) => {
-                if (settled)
-                    return;
-                if (metadata.streamingStart) {
-                    streamStarted = true;
-                    streamStartedAtMs = Date.now();
-                    streamBufferedBytes = 0;
-                    streamStartResponse = this._stripStreamingHeader(response);
-                    debugLog(`[Node] Stream started for ${req.requestId.slice(0, 8)}; idle-timeout=${streamIdleTimeoutMs}ms`);
-                    // Switch to streaming idle timeout: resets on each chunk.
-                    resetTimeout(streamIdleTimeoutMs);
-                    callbacks?.onResponseStart?.(streamStartResponse, { streaming: true });
-                    return;
-                }
-                callbacks?.onResponseStart?.(this._stripStreamingHeader(response), { streaming: false });
-                finish(response);
-            }, (chunk) => {
-                if (settled)
-                    return;
-                if (!streamStarted)
-                    return;
-                // Reset idle timeout on each chunk so streaming stays alive.
-                resetTimeout(streamIdleTimeoutMs);
-                if (Date.now() - streamStartedAtMs > maxStreamDurationMs) {
-                    mux.cancelProxyRequest(req.requestId);
-                    fail(new Error(`Stream ${req.requestId} exceeded max duration (${maxStreamDurationMs}ms)`));
-                    return;
-                }
-                callbacks?.onResponseChunk?.(chunk);
-                if (chunk.data.length > 0) {
-                    if (callbacks?.onResponseChunk) {
-                        // Streaming mode: chunks already delivered to caller via callback.
-                        // Track byte count for the debug timeout log only — do not
-                        // enforce maxStreamBufferBytes so large streams aren't rejected.
-                        streamBufferedBytes += chunk.data.length;
-                        streamChunks.push(chunk.data);
-                    }
-                    else {
-                        // Non-streaming: accumulate chunks for the final response body.
-                        const nextBufferedBytes = streamBufferedBytes + chunk.data.length;
-                        if (nextBufferedBytes > maxStreamBufferBytes) {
-                            mux.cancelProxyRequest(req.requestId);
-                            fail(new Error(`Stream ${req.requestId} exceeded max buffered size (${maxStreamBufferBytes} bytes)`));
-                            return;
-                        }
-                        streamBufferedBytes = nextBufferedBytes;
-                        streamChunks.push(chunk.data);
-                    }
-                }
-                if (!chunk.done)
-                    return;
-                if (!streamStartResponse) {
-                    fail(new Error(`Stream ${req.requestId} ended before response start`));
-                    return;
-                }
-                finish({
-                    ...streamStartResponse,
-                    body: concatChunks(streamChunks),
-                });
-            });
-        });
+        if (!this._buyerHandler)
+            throw new Error("Node not started or not in buyer mode");
+        return this._buyerHandler.sendRequest(peer, req, callbacks, options);
     }
     _createDHTConfig(port, bootstrapNodes) {
         return {
@@ -546,8 +421,15 @@ export class AntseedNode extends EventEmitter {
                 this._muxes.delete(peerId);
                 this._paymentMuxes.delete(peerId);
                 this._decoders.delete(peerId);
-                // Handle buyer disconnect (ghost scenario)
-                void this._finalizeSession(peerId, "disconnect");
+                // Clean up buyer-side payment state on disconnect
+                this._buyerNegotiator?.onPeerDisconnect(peerId);
+                // Handle buyer disconnect (seller side)
+                if (this._sellerPaymentManager) {
+                    this._sellerPaymentManager.onBuyerDisconnect(peerId);
+                }
+                if (this._sessionTracker) {
+                    void this._sessionTracker.finalizeSession(peerId, "disconnect");
+                }
             }
         });
         // Start keepalive pings on outbound (buyer-initiated) connections to
@@ -580,7 +462,6 @@ export class AntseedNode extends EventEmitter {
         const dhtPort = this._config.dhtPort ?? 6881;
         const signalingPort = this._config.signalingPort ?? 6882;
         debugLog(`[Node] Starting seller — DHT port=${dhtPort}, signaling port=${signalingPort}`);
-        // Initialize metering storage
         const dataDir = this._config.dataDir ?? join(homedir(), ".antseed");
         try {
             this._metering = new MeteringStorage(join(dataDir, "metering.db"));
@@ -592,10 +473,25 @@ export class AntseedNode extends EventEmitter {
         if (this._metering) {
             this._receiptGenerator = new ReceiptGenerator({
                 peerId: identity.peerId,
-                sign: (message) => signUtf8Ed25519(identity.privateKey, message),
+                sign: (message) => signUtf8(identity.wallet, message),
             });
         }
+        // Initialize seller session tracker
+        this._sessionTracker = new SellerSessionTracker(identity, this._metering, this._receiptGenerator, { settlementIdleMs: this._config.payments?.settlementIdleMs }, {
+            onSessionUpdated: (snapshot) => this.emit("session:updated", snapshot),
+            onSessionFinalized: (info) => this.emit("session:finalized", info),
+        });
         await this._initializePayments(dataDir);
+        // Wire idle-timeout session finalization to on-chain settlement
+        if (this._sellerPaymentManager) {
+            const spm = this._sellerPaymentManager;
+            this.on("session:finalized", (info) => {
+                if (info.reason === "idle-timeout") {
+                    debugLog(`[Node] Idle timeout for buyer ${info.buyerPeerId.slice(0, 12)}... — settling channel`);
+                    void spm.settleSession(info.buyerPeerId, { cleanupOnFailure: true });
+                }
+            });
+        }
         // Start DHT
         this._dht = new DHTNode(this._createDHTConfig(dhtPort, bootstrapNodes));
         await this._dht.start();
@@ -654,12 +550,23 @@ export class AntseedNode extends EventEmitter {
                 ])),
                 reannounceIntervalMs: DEFAULT_DHT_CONFIG.reannounceIntervalMs,
                 signalingPort: actualSignalingPort,
+                ...(this._channelsClient ? { channelsClient: this._channelsClient } : {}),
+                ...(this._stakingClient ? { stakingClient: this._stakingClient, paymentsEnabled: true } : {}),
             };
             this._announcer = new PeerAnnouncer(announcerConfig);
             this._announcer.startPeriodicAnnounce();
             // Serve metadata on the signaling port (HTTP requests are auto-detected)
             this._connectionManager.setMetadataProvider(() => this._announcer?.getLatestMetadata() ?? null);
         }
+        // Create seller request handler
+        this._sellerHandler = new SellerRequestHandler({
+            providers: this._providers,
+            sellerPaymentManager: this._sellerPaymentManager,
+            sessionTracker: this._sessionTracker,
+            channelsClient: this._channelsClient,
+            announcer: this._announcer,
+            emit: (event, ...args) => this.emit(event, ...args),
+        });
         // Listen for incoming connections
         this._connectionManager.on("connection", (conn) => {
             this._handleIncomingConnection(conn);
@@ -670,6 +577,8 @@ export class AntseedNode extends EventEmitter {
         const identity = this._identity;
         const dhtPort = this._config.dhtPort ?? 0;
         debugLog(`[Node] Starting buyer — DHT port=${dhtPort}`);
+        const dataDir = this._config.dataDir ?? join(homedir(), ".antseed");
+        await this._initializePayments(dataDir);
         // Start DHT with ephemeral port
         this._dht = new DHTNode(this._createDHTConfig(dhtPort, bootstrapNodes));
         await this._dht.start();
@@ -692,464 +601,174 @@ export class AntseedNode extends EventEmitter {
         this._peerLookup = new PeerLookup(lookupConfig);
         // Initialize buyer-side payment manager if payments config is provided
         const payments = this._config.payments;
-        if (payments?.enabled && payments.rpcUrl && payments.contractAddress && payments.usdcAddress) {
-            const buyerPaymentConfig = {
-                defaultLockAmountUSDC: payments.defaultEscrowAmountUSDC ?? "1000000",
-                rpcUrl: payments.rpcUrl,
-                contractAddress: payments.contractAddress,
-                usdcAddress: payments.usdcAddress,
-            };
-            this._buyerPaymentManager = new BuyerPaymentManager(identity, buyerPaymentConfig);
-            debugLog(`[Node] Buyer payment manager initialized (wallet=${identityToEvmAddress(identity).slice(0, 10)}...)`);
-        }
+        if (payments?.enabled && payments.rpcUrl && payments.depositsAddress && payments.channelsAddress && payments.usdcAddress) {
+            const paymentsDir = join(dataDir, "payments");
+            // Create shared ChannelStore for both buyer and seller payment managers
+            if (!this._channelStore) {
+                try {
+                    this._channelStore = new ChannelStore(paymentsDir);
+                    debugLog("[Node] ChannelStore initialized (buyer)");
+                }
+                catch (err) {
+                    debugWarn(`[Node] ChannelStore unavailable: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+            if (this._channelStore) {
+                const buyerPaymentConfig = {
+                    rpcUrl: payments.rpcUrl,
+                    depositsContractAddress: payments.depositsAddress,
+                    channelsContractAddress: payments.channelsAddress,
+                    usdcAddress: payments.usdcAddress,
+                    identityRegistryAddress: payments.identityRegistryAddress ?? '',
+                    chainId: payments.chainId ?? 8453,
+                    defaultAuthDurationSecs: payments.defaultAuthDurationSecs ?? 900, // 15 min — seller must call reserve() promptly
+                    maxPerRequestUsdc: BigInt(payments.maxPerRequestUsdc ?? "500000"), // $0.50 default — covers most LLM requests
+                    maxReserveAmountUsdc: BigInt(payments.maxReserveAmountUsdc ?? "1000000"), // $1.00 default per session (matches FIRST_SIGN_CAP)
+                    dataDir: paymentsDir,
+                };
+                this._buyerPaymentManager = new BuyerPaymentManager(identity, buyerPaymentConfig, this._channelStore);
+                debugLog(`[Node] Buyer payment manager initialized (wallet=${identity.wallet.address.slice(0, 10)}... chainId=${buyerPaymentConfig.chainId} deposits=${buyerPaymentConfig.depositsContractAddress.slice(0, 10)}...)`);
+                // Create negotiator that wraps the BPM with 402 handling and per-request auth
+                this._buyerNegotiator = new BuyerPaymentNegotiator(identity, this._buyerPaymentManager, this._depositsClient, this._channelsClient, this._channelStore, {}, this);
+                debugLog(`[Node] Buyer payment negotiator initialized`);
+            }
+        }
+        // Create buyer request handler
+        this._buyerHandler = new BuyerRequestHandler({
+            requestTimeoutMs: this._config.requestTimeoutMs,
+            maxStreamBufferBytes: this._config.maxStreamBufferBytes,
+            maxStreamDurationMs: this._config.maxStreamDurationMs,
+        }, {
+            negotiator: this._buyerNegotiator,
+            getConnection: (peer) => this._getOrCreateConnection(peer),
+            getMux: (peerId, conn) => this._getOrCreateMux(peerId, conn),
+            registerPaymentMux: (peerId, pmux) => this._paymentMuxes.set(peerId, pmux),
+        });
         debugLog(`[Node] Buyer ready — DHT running on port ${this._dht.getPort()}`);
     }
     _handleIncomingConnection(conn) {
         debugLog(`[Node] Incoming connection from ${conn.remotePeerId.slice(0, 12)}...`);
         const buyerPeerId = conn.remotePeerId;
-        const mux = new ProxyMux(conn);
         // Create PaymentMux alongside ProxyMux (seller-side)
         const paymentMux = new PaymentMux(conn);
-        paymentMux.onSessionLockAuth((payload) => {
-            void this._handleSessionLockAuth(buyerPeerId, payload, paymentMux);
-        });
-        paymentMux.onBuyerAck((payload) => {
-            void this._handleBuyerAck(buyerPeerId, payload);
-        });
-        paymentMux.onSessionEnd((payload) => {
-            void this._handleSessionEnd(buyerPeerId, payload);
-        });
-        paymentMux.onTopUpAuth((payload) => {
-            void this._handleTopUpAuth(buyerPeerId, payload);
-        });
-        this._paymentMuxes.set(buyerPeerId, paymentMux);
-        // Register the ProxyMux request handler that routes to providers
-        mux.onProxyRequest(async (request) => {
-            debugLog(`[Node] Seller received request: ${request.method} ${request.path} (reqId=${request.requestId.slice(0, 8)})`);
-            // Reject with 402 if lock not committed and escrow client is configured
-            const session = this._sessions.get(buyerPeerId);
-            if (this._escrowClient && (!session || !session.lockCommitted)) {
-                debugWarn(`[Node] Rejecting request from ${buyerPeerId.slice(0, 12)}... — lock not committed`);
-                mux.sendProxyResponse({
-                    requestId: request.requestId,
-                    statusCode: 402,
-                    headers: { "content-type": "text/plain" },
-                    body: new TextEncoder().encode("Payment required: session lock not committed"),
-                });
-                return;
-            }
-            const requestedService = this._extractRequestedService(request);
-            const requestedProvider = this._extractRequestedProvider(request);
-            const matchesService = (provider) => provider.services.length === 0
-                || (requestedService !== null && provider.services.includes(requestedService))
-                || this._providers.length === 1;
-            let provider;
-            if (requestedProvider) {
-                provider = this._providers.find((candidate) => candidate.name.toLowerCase() === requestedProvider && matchesService(candidate));
-            }
-            if (!provider) {
-                provider = this._providers.find((candidate) => matchesService(candidate));
-            }
-            if (!provider) {
-                debugWarn(`[Node] No matching provider for ${request.path}`);
-                mux.sendProxyResponse({
-                    requestId: request.requestId,
-                    statusCode: 502,
-                    headers: { "content-type": "text/plain" },
-                    body: new TextEncoder().encode("No matching provider"),
-                });
-                return;
-            }
-            // Track active seller session at request start so runtime state reflects
-            // in-flight work immediately (not only after metering persistence).
-            this._getOrCreateSellerSession(buyerPeerId, provider.name);
-            request.headers['x-antseed-buyer-peer-id'] = buyerPeerId;
-            debugLog(`[Node] Routing to provider "${provider.name}"`);
-            const startTime = Date.now();
-            let statusCode = 500;
-            let responseBody = new Uint8Array(0);
-            let streamedResponseStarted = false;
-            this._adjustProviderLoad(provider.name, 1);
-            try {
-                try {
-                    const response = await this._executeProviderRequest(provider, request, {
-                        onResponseStart: (streamResponseStart) => {
-                            streamedResponseStarted = true;
-                            statusCode = streamResponseStart.statusCode;
-                            mux.sendProxyResponse(streamResponseStart);
-                        },
-                        onResponseChunk: (chunk) => {
-                            if (!streamedResponseStarted)
-                                return;
-                            mux.sendProxyChunk(chunk);
-                        },
-                    });
-                    statusCode = response.statusCode;
-                    responseBody = response.body;
-                    debugLog(`[Node] Provider responded: status=${statusCode} (${Date.now() - startTime}ms, ${responseBody.length}b)`);
-                    if (!streamedResponseStarted) {
-                        mux.sendProxyResponse(response);
-                    }
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : "Internal error";
-                    debugWarn(`[Node] Provider error after ${Date.now() - startTime}ms: ${message}`);
-                    responseBody = new TextEncoder().encode(message);
-                    if (streamedResponseStarted) {
-                        mux.sendProxyChunk({
-                            requestId: request.requestId,
-                            data: new TextEncoder().encode(`event: error\ndata: ${message}\n\n`),
-                            done: false,
-                        });
-                        mux.sendProxyChunk({
-                            requestId: request.requestId,
-                            data: new Uint8Array(0),
-                            done: true,
-                        });
-                    }
-                    else {
-                        statusCode = 500;
-                        mux.sendProxyResponse({
-                            requestId: request.requestId,
-                            statusCode: 500,
-                            headers: { "content-type": "text/plain" },
-                            body: responseBody,
-                        });
+        if (this._sellerPaymentManager) {
+            const spm = this._sellerPaymentManager;
+            paymentMux.onSpendingAuth((payload) => {
+                void spm.handleSpendingAuth(buyerPeerId, payload, paymentMux)
+                    .then((status) => {
+                    if (status === 'rejected') {
+                        debugWarn(`[Node] SpendingAuth rejected for buyer ${buyerPeerId.slice(0, 12)}... — notifying via payment:auth-rejected event`);
+                        this.emit('payment:auth-rejected', { buyerPeerId, reason: 'invalid_or_non_monotonic' });
                     }
-                }
-                // Record metering
-                const latencyMs = Date.now() - startTime;
-                const requestPricing = this._resolveProviderPricing(provider, request);
-                await this._recordMetering(buyerPeerId, provider.name, requestPricing, request, statusCode, latencyMs, request.body.length, responseBody.length);
-                // Generate bilateral receipt after each request if lock committed (Task 3)
-                const currentSession = this._sessions.get(buyerPeerId);
-                if (currentSession?.lockCommitted) {
-                    await this._sendBilateralReceipt(buyerPeerId, currentSession, requestPricing, responseBody, paymentMux);
-                }
-            }
-            finally {
-                this._adjustProviderLoad(provider.name, -1);
-            }
-        });
+                })
+                    .catch((err) => {
+                    debugWarn(`[Node] SpendingAuth handler error for ${buyerPeerId.slice(0, 12)}...: ${err instanceof Error ? err.message : err}`);
+                });
+            });
+        }
+        else {
+            paymentMux.onSpendingAuth(() => {
+                debugWarn(`[Node] SpendingAuth rejected — SellerPaymentManager not configured`);
+            });
+        }
+        this._paymentMuxes.set(buyerPeerId, paymentMux);
+        const { mux } = this._sellerHandler.handleConnection(conn, buyerPeerId, paymentMux);
         this._muxes.set(buyerPeerId, mux);
         this._wireConnection(conn, buyerPeerId);
         this.emit("connection", conn);
     }
-    async _executeProviderRequest(provider, request, streamCallbacks) {
-        if (streamCallbacks && provider.handleRequestStream) {
-            return provider.handleRequestStream(request, streamCallbacks);
-        }
-        return provider.handleRequest(request);
-    }
-    _stripStreamingHeader(response) {
-        if (response.headers[ANTSEED_STREAMING_RESPONSE_HEADER] !== "1") {
-            return response;
-        }
-        const headers = { ...response.headers };
-        delete headers[ANTSEED_STREAMING_RESPONSE_HEADER];
-        return {
-            ...response,
-            headers,
-        };
-    }
-    _parseJsonBody(body) {
-        try {
-            return JSON.parse(new TextDecoder().decode(body));
-        }
-        catch {
-            return null;
-        }
-    }
-    _extractRequestedService(request) {
-        const contentType = request.headers["content-type"] ?? request.headers["Content-Type"] ?? "";
-        if (!contentType.toLowerCase().includes("application/json")) {
-            return null;
-        }
-        const parsed = this._parseJsonBody(request.body);
-        if (!parsed || typeof parsed !== "object") {
-            return null;
-        }
-        const service = parsed["model"];
-        if (typeof service !== "string" || service.trim().length === 0) {
-            return null;
-        }
-        return service.trim();
-    }
-    _extractRequestedProvider(request) {
-        const providers = Object.entries(request.headers)
-            .filter(([header]) => header.toLowerCase() === "x-antseed-provider")
-            .map(([, value]) => value.trim().toLowerCase())
-            .filter((value) => value.length > 0);
-        return providers[0] ?? null;
-    }
-    _resolveProviderPricing(provider, request) {
-        const requestedService = this._extractRequestedService(request);
-        if (requestedService) {
-            const servicePricing = provider.pricing.services?.[requestedService];
-            if (servicePricing) {
-                return servicePricing;
-            }
-        }
-        return provider.pricing.defaults;
-    }
-    _getOrCreateSellerSession(buyerPeerId, providerName) {
-        if (!this._identity) {
-            return null;
-        }
-        let session = this._sessions.get(buyerPeerId);
-        if (!session) {
-            const now = Date.now();
-            const sessionId = randomUUID();
-            // Generate 32-byte sessionIdBytes from UUID for on-chain use
-            const sessionIdBytes = createHash("sha256").update(sessionId).digest();
-            session = {
-                sessionId,
-                sessionIdBytes: new Uint8Array(sessionIdBytes),
-                startedAt: now,
-                lastActivityAt: now,
-                totalRequests: 0,
-                totalTokens: 0,
-                totalLatencyMs: 0,
-                totalCostCents: 0,
-                provider: providerName,
-                lockCommitted: false,
-                lockedAmount: 0n,
-                runningTotal: 0n,
-                ackedRequestCount: 0,
-                lastAckedTotal: 0n,
-                awaitingAck: false,
-                buyerEvmAddress: null,
-            };
-            this._sessions.set(buyerPeerId, session);
-        }
-        session.provider = providerName;
-        session.lastActivityAt = Date.now();
-        this._emitSellerSessionUpdated(buyerPeerId, session);
-        return session;
-    }
-    _emitSellerSessionUpdated(buyerPeerId, session) {
-        this.emit("session:updated", {
-            buyerPeerId,
-            sessionId: session.sessionId,
-            provider: session.provider,
-            startedAt: session.startedAt,
-            lastActivityAt: session.lastActivityAt,
-            totalRequests: session.totalRequests,
-            totalTokens: session.totalTokens,
-            avgLatencyMs: session.totalRequests > 0 ? session.totalLatencyMs / session.totalRequests : 0,
-            settling: Boolean(session.settling),
-        });
-    }
-    /** Estimate tokens from byte lengths (rough: ~4 chars per token). */
-    _estimateTokens(inputBytes, outputBytes) {
-        const inputTokens = Math.max(1, Math.round(inputBytes / 4));
-        const outputTokens = Math.max(1, Math.round(outputBytes / 4));
-        return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
-    }
-    async _recordMetering(buyerPeerId, providerName, providerPricingUsdPerMillion, request, statusCode, latencyMs, inputBytes, outputBytes) {
-        if (!this._identity)
-            return;
-        const sellerPeerId = this._identity.peerId;
-        const isSSE = request.headers["accept"]?.includes("text/event-stream") ?? false;
-        const tokens = this._estimateTokens(inputBytes, outputBytes);
-        // Get or create session for this buyer
-        const session = this._getOrCreateSellerSession(buyerPeerId, providerName);
-        if (!session)
-            return;
-        session.totalRequests++;
-        session.totalTokens += tokens.totalTokens;
-        session.totalLatencyMs += latencyMs;
-        session.provider = providerName;
-        session.lastActivityAt = Date.now();
-        this._emitSellerSessionUpdated(buyerPeerId, session);
-        const metering = this._metering;
-        if (!metering) {
-            this._scheduleSettlementTimer(buyerPeerId);
-            return;
-        }
-        // Record metering event
-        const event = {
-            eventId: randomUUID(),
-            sessionId: session.sessionId,
-            timestamp: Date.now(),
-            provider: providerName,
-            sellerPeerId,
-            buyerPeerId,
-            tokens: { ...tokens, method: "content-length", confidence: "low" },
-            latencyMs,
-            statusCode,
-            wasStreaming: isSSE,
-        };
-        try {
-            metering.insertEvent(event);
-        }
-        catch (err) {
-            debugWarn(`[Node] Failed to record metering event: ${err instanceof Error ? err.message : err}`);
-        }
-        if (this._receiptGenerator) {
-            const estimatedCostUsd = (tokens.inputTokens * providerPricingUsdPerMillion.inputUsdPerMillion +
-                tokens.outputTokens * providerPricingUsdPerMillion.outputUsdPerMillion) /
-                1_000_000;
-            const effectiveUsdPerThousandTokens = tokens.totalTokens > 0 ? (estimatedCostUsd / tokens.totalTokens) * 1000 : 0;
-            // Receipt unit pricing uses USD cents per 1,000 tokens.
-            const unitPriceCentsPerThousandTokens = Math.max(0, effectiveUsdPerThousandTokens * 100);
-            const receipt = this._receiptGenerator.generate(session.sessionId, event.eventId, providerName, buyerPeerId, event.tokens, unitPriceCentsPerThousandTokens);
-            try {
-                metering.insertReceipt(receipt);
-                session.totalCostCents += receipt.costCents;
-            }
-            catch (err) {
-                debugWarn(`[Node] Failed to record usage receipt: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        // Upsert session
-        const sessionMetrics = {
-            sessionId: session.sessionId,
-            sellerPeerId,
-            buyerPeerId,
-            provider: providerName,
-            startedAt: session.startedAt,
-            endedAt: null,
-            totalRequests: session.totalRequests,
-            totalTokens: session.totalTokens,
-            totalCostCents: session.totalCostCents,
-            avgLatencyMs: session.totalLatencyMs / session.totalRequests,
-            peerSwitches: 0,
-            disputedReceipts: 0,
-        };
-        try {
-            metering.upsertSession(sessionMetrics);
-        }
-        catch (err) {
-            debugWarn(`[Node] Failed to upsert session: ${err instanceof Error ? err.message : err}`);
-        }
-        this._scheduleSettlementTimer(buyerPeerId);
-    }
     async _initializePayments(dataDir) {
         const payments = this._config.payments;
         if (!payments || !payments.enabled) {
             return;
         }
-        // Initialize BaseEscrowClient if Base config is provided
-        if (payments.rpcUrl && payments.contractAddress && payments.usdcAddress) {
-            this._escrowClient = new BaseEscrowClient({
+        // Initialize DepositsClient
+        if (payments.rpcUrl && payments.depositsAddress && payments.usdcAddress) {
+            this._depositsClient = new DepositsClient({
                 rpcUrl: payments.rpcUrl,
-                contractAddress: payments.contractAddress,
+                contractAddress: payments.depositsAddress,
                 usdcAddress: payments.usdcAddress,
             });
-            debugLog(`[Node] BaseEscrowClient initialized (contract=${payments.contractAddress.slice(0, 10)}...)`);
-        }
-        if (!this._metering) {
-            debugWarn("[Node] Payments enabled but metering storage is unavailable; skipping balance manager wiring");
-            return;
+            debugLog(`[Node] DepositsClient initialized (contract=${payments.depositsAddress.slice(0, 10)}...)`);
         }
-        const paymentsDir = join(dataDir, "payments");
-        this._balanceManager = new BalanceManager();
-        await this._balanceManager.load(paymentsDir).catch((err) => {
-            debugWarn(`[Node] Failed to load payment balances: ${err instanceof Error ? err.message : err}`);
-        });
-    }
-    _scheduleSettlementTimer(buyerPeerId) {
-        const existing = this._settlementTimers.get(buyerPeerId);
-        if (existing) {
-            clearTimeout(existing);
-        }
-        const idleMs = this._config.payments?.settlementIdleMs ?? 30_000;
-        const timer = setTimeout(() => {
-            void this._finalizeSession(buyerPeerId, "idle-timeout");
-        }, idleMs);
-        if (typeof timer.unref === "function") {
-            timer.unref();
+        // Initialize ChannelsClient
+        if (payments.rpcUrl && payments.channelsAddress) {
+            this._channelsClient = new ChannelsClient({
+                rpcUrl: payments.rpcUrl,
+                contractAddress: payments.channelsAddress,
+            });
+            debugLog(`[Node] ChannelsClient initialized (contract=${payments.channelsAddress.slice(0, 10)}...)`);
         }
-        this._settlementTimers.set(buyerPeerId, timer);
-    }
-    async _finalizeSession(buyerPeerId, reason) {
-        const session = this._sessions.get(buyerPeerId);
-        if (!session || session.settling) {
-            return;
+        // Initialize StakingClient
+        if (payments.rpcUrl && payments.stakingAddress && payments.usdcAddress) {
+            this._stakingClient = new StakingClient({
+                rpcUrl: payments.rpcUrl,
+                contractAddress: payments.stakingAddress,
+                usdcAddress: payments.usdcAddress,
+            });
+            debugLog(`[Node] StakingClient initialized (contract=${payments.stakingAddress.slice(0, 10)}...)`);
         }
-        session.settling = true;
-        const timer = this._settlementTimers.get(buyerPeerId);
-        if (timer) {
-            clearTimeout(timer);
-            this._settlementTimers.delete(buyerPeerId);
+        // Initialize IdentityClient (ERC-8004 IdentityRegistry)
+        if (payments.rpcUrl && payments.identityRegistryAddress) {
+            this._identityClient = new IdentityClient({
+                rpcUrl: payments.rpcUrl,
+                contractAddress: payments.identityRegistryAddress,
+            });
+            debugLog(`[Node] IdentityClient initialized (contract=${payments.identityRegistryAddress.slice(0, 10)}...)`);
         }
-        // Bilateral-aware disconnect handling (ghost scenario - Task 7)
-        if (session.lockCommitted && this._escrowClient && this._identity && reason === "disconnect") {
-            const sellerWallet = identityToEvmWallet(this._identity);
-            const sessionIdHex = "0x" + bytesToHex(session.sessionIdBytes);
+        // Initialize ChannelStore for persistent payment channels (shared instance)
+        const paymentsDir = join(dataDir, "payments");
+        if (!this._channelStore) {
             try {
-                if (session.lastAckedTotal > 0n) {
-                    // Buyer acked some work — open dispute with last acked total
-                    debugLog(`[Node] Ghost buyer — opening dispute with lastAckedTotal=${session.lastAckedTotal}`);
-                    await this._escrowClient.openDispute(sellerWallet, sessionIdHex, session.lastAckedTotal);
-                }
-                else if (session.runningTotal > 0n) {
-                    // No acks but work was done — open dispute with running total
-                    debugLog(`[Node] Ghost buyer — opening dispute with runningTotal=${session.runningTotal}`);
-                    await this._escrowClient.openDispute(sellerWallet, sessionIdHex, session.runningTotal);
-                }
-                else {
-                    // No work done — lock expires after 1 hour automatically
-                    debugLog(`[Node] Ghost buyer — no work done, lock will expire`);
-                }
+                this._channelStore = new ChannelStore(paymentsDir);
+                debugLog("[Node] ChannelStore initialized");
             }
             catch (err) {
-                debugWarn(`[Node] Failed to handle ghost buyer for session ${session.sessionId}: ${err instanceof Error ? err.message : err}`);
+                debugWarn(`[Node] ChannelStore unavailable: ${err instanceof Error ? err.message : err}`);
             }
-            this._sessions.delete(buyerPeerId);
-            this.emit("session:finalized", {
-                buyerPeerId,
-                sessionId: session.sessionId,
-                reason: "ghost-disconnect",
-            });
-            return;
         }
-        if (!this._metering || !this._identity) {
-            this._sessions.delete(buyerPeerId);
-            return;
-        }
-        const now = Date.now();
-        const baseMetrics = {
-            sessionId: session.sessionId,
-            sellerPeerId: this._identity.peerId,
-            buyerPeerId,
-            provider: session.provider,
-            startedAt: session.startedAt,
-            endedAt: now,
-            totalRequests: session.totalRequests,
-            totalTokens: session.totalTokens,
-            totalCostCents: session.totalCostCents,
-            avgLatencyMs: session.totalRequests > 0 ? session.totalLatencyMs / session.totalRequests : 0,
-            peerSwitches: 0,
-            disputedReceipts: 0,
-        };
-        try {
-            this._metering.upsertSession(baseMetrics);
-            this._sessions.delete(buyerPeerId);
-            this.emit("session:finalized", {
-                buyerPeerId,
-                sessionId: session.sessionId,
-                reason,
-            });
-        }
-        catch (err) {
-            session.settling = false;
-            debugWarn(`[Node] Failed to finalize session ${session.sessionId}: ${err instanceof Error ? err.message : err}`);
-            const retry = setTimeout(() => {
-                void this._finalizeSession(buyerPeerId, "retry");
-            }, 10_000);
-            if (typeof retry.unref === "function") {
-                retry.unref();
+        // Initialize SellerPaymentManager for seller role
+        if (this._config.role === 'seller' && this._identity && this._channelStore &&
+            payments.rpcUrl && payments.channelsAddress) {
+            const sellerConfig = {
+                rpcUrl: payments.rpcUrl,
+                channelsContractAddress: payments.channelsAddress,
+                chainId: payments.chainId ?? 8453,
+                dataDir: paymentsDir,
+                ...(payments.minBudgetPerRequest ? { minBudgetPerRequest: payments.minBudgetPerRequest } : {}),
+            };
+            this._sellerPaymentManager = new SellerPaymentManager(this._identity, sellerConfig, this._channelStore);
+            debugLog(`[Node] SellerPaymentManager initialized`);
+            // Startup recovery: check for timed-out sessions
+            await this._sellerPaymentManager.checkTimeouts();
+            // Initialize CloseRequested polling cursor to current block
+            try {
+                this._closeRequestedFromBlock = await this._sellerPaymentManager.channelsClient.getBlockNumber();
+            }
+            catch {
+                this._closeRequestedFromBlock = 0;
+            }
+            // Start periodic timeout checker + CloseRequested poller (every 60s)
+            this._timeoutCheckerInterval = setInterval(() => {
+                void this._sellerPaymentManager?.checkTimeouts();
+                if (this._sellerPaymentManager) {
+                    void this._sellerPaymentManager.pollCloseRequested(this._closeRequestedFromBlock).then((nextBlock) => {
+                        this._closeRequestedFromBlock = nextBlock;
+                    });
+                }
+            }, 60_000);
+            if (typeof this._timeoutCheckerInterval.unref === "function") {
+                this._timeoutCheckerInterval.unref();
             }
-            this._settlementTimers.set(buyerPeerId, retry);
         }
-    }
-    async _finalizeAllSessions(reason) {
-        if (this._sessions.size === 0)
+        if (!this._metering) {
+            debugWarn("[Node] Payments enabled but metering storage is unavailable; skipping balance manager wiring");
             return;
-        const buyers = [...this._sessions.keys()];
-        await Promise.allSettled(buyers.map((buyerPeerId) => this._finalizeSession(buyerPeerId, reason)));
+        }
+        this._balanceManager = new BalanceManager();
+        await this._balanceManager.load(paymentsDir).catch((err) => {
+            debugWarn(`[Node] Failed to load payment balances: ${err instanceof Error ? err.message : err}`);
+        });
     }
     async _getOrCreateConnection(peer) {
         if (!this._connectionManager || !this._identity) {
@@ -1235,292 +854,6 @@ export class AntseedNode extends EventEmitter {
         this._muxes.set(peerId, mux);
         return mux;
     }
-    // ── Seller-side bilateral payment handlers ─────────────────────
-    /**
-     * Handle SessionLockAuth from buyer (Task 2).
-     * Recovers buyer address, commits lock on-chain, initializes bilateral state.
-     */
-    async _handleSessionLockAuth(buyerPeerId, payload, paymentMux) {
-        if (!this._identity || !this._escrowClient) {
-            paymentMux.sendSessionLockReject({
-                sessionId: payload.sessionId,
-                reason: "Escrow client not configured",
-            });
-            return;
-        }
-        try {
-            const sellerWallet = identityToEvmWallet(this._identity);
-            const lockedAmount = BigInt(payload.lockedAmount);
-            // Recover buyer address from ECDSA signature
-            const lockMsgHash = buildLockMessageHash(payload.sessionId, sellerWallet.address, lockedAmount);
-            const buyerEvmAddress = verifyMessage(getBytes(lockMsgHash), payload.buyerSig);
-            // Submit commit_lock on-chain
-            const txHash = await this._escrowClient.commitLock(sellerWallet, buyerEvmAddress, payload.sessionId, lockedAmount, payload.buyerSig);
-            // Initialize or update bilateral session state
-            let session = this._sessions.get(buyerPeerId);
-            if (!session) {
-                session = this._getOrCreateSellerSession(buyerPeerId, this._providers[0]?.name ?? "unknown");
-            }
-            if (session) {
-                // Override sessionId with the one from the lock auth (buyer-chosen)
-                session.sessionId = payload.sessionId;
-                session.sessionIdBytes = hexToBytes(payload.sessionId.replace(/^0x/, ""));
-                session.lockCommitted = true;
-                session.lockedAmount = lockedAmount;
-                session.runningTotal = 0n;
-                session.ackedRequestCount = 0;
-                session.lastAckedTotal = 0n;
-                session.awaitingAck = false;
-                session.buyerEvmAddress = buyerEvmAddress;
-            }
-            debugLog(`[Node] Lock committed for buyer ${buyerPeerId.slice(0, 12)}... amount=${lockedAmount} tx=${txHash.slice(0, 12)}...`);
-            paymentMux.sendSessionLockConfirm({
-                sessionId: payload.sessionId,
-                txSignature: txHash,
-            });
-        }
-        catch (err) {
-            const reason = err instanceof Error ? err.message : String(err);
-            debugWarn(`[Node] Failed to commit lock for ${buyerPeerId.slice(0, 12)}...: ${reason}`);
-            paymentMux.sendSessionLockReject({
-                sessionId: payload.sessionId,
-                reason,
-            });
-        }
-    }
-    /**
-     * Generate and send a bilateral receipt after processing a request (Task 3).
-     */
-    async _sendBilateralReceipt(_buyerPeerId, session, providerPricingUsdPerMillion, responseBody, paymentMux) {
-        if (!this._identity)
-            return;
-        // Calculate incremental cost in USDC base units (6 decimals)
-        // Estimate tokens from response body size
-        const tokens = this._estimateTokens(0, responseBody.length);
-        const costUSD = (tokens.inputTokens * providerPricingUsdPerMillion.inputUsdPerMillion +
-            tokens.outputTokens * providerPricingUsdPerMillion.outputUsdPerMillion) /
-            1_000_000;
-        const costBaseUnits = BigInt(Math.round(costUSD * 1_000_000));
-        // Update running total
-        session.runningTotal += costBaseUnits;
-        // SHA-256 hash of response body for proof of work
-        const responseHash = createHash("sha256").update(responseBody).digest();
-        // Build receipt message and sign with Ed25519
-        const receiptMsg = buildReceiptMessage(session.sessionIdBytes, session.runningTotal, session.totalRequests, new Uint8Array(responseHash));
-        const sellerSig = await signMessageEd25519(this._identity, receiptMsg);
-        paymentMux.sendSellerReceipt({
-            sessionId: session.sessionId,
-            runningTotal: session.runningTotal.toString(),
-            requestCount: session.totalRequests,
-            responseHash: bytesToHex(new Uint8Array(responseHash)),
-            sellerSig: bytesToHex(sellerSig),
-        });
-        session.awaitingAck = true;
-        // Send TopUpRequest if running total > 80% of locked amount
-        if (session.lockedAmount > 0n && session.runningTotal * 100n > session.lockedAmount * 80n) {
-            const additionalAmount = session.lockedAmount; // Request same amount again
-            paymentMux.sendTopUpRequest({
-                sessionId: session.sessionId,
-                additionalAmount: additionalAmount.toString(),
-                currentRunningTotal: session.runningTotal.toString(),
-                currentLockedAmount: session.lockedAmount.toString(),
-            });
-            debugLog(`[Node] TopUpRequest sent for session ${session.sessionId.slice(0, 8)}... (running=${session.runningTotal}, locked=${session.lockedAmount})`);
-        }
-    }
-    /**
-     * Handle BuyerAck (Task 4).
-     * Verifies buyer's Ed25519 ack signature and updates session state.
-     */
-    async _handleBuyerAck(buyerPeerId, payload) {
-        const session = this._sessions.get(buyerPeerId);
-        if (!session || !session.lockCommitted) {
-            debugWarn(`[Node] Received BuyerAck for unknown/uncommitted session from ${buyerPeerId.slice(0, 12)}...`);
-            return;
-        }
-        try {
-            // Verify buyer's Ed25519 ack signature
-            const buyerPublicKey = hexToBytes(buyerPeerId);
-            const ackMsg = buildAckMessage(session.sessionIdBytes, BigInt(payload.runningTotal), payload.requestCount);
-            const sigBytes = hexToBytes(payload.buyerSig);
-            const valid = await verifyMessageEd25519(buyerPublicKey, sigBytes, ackMsg);
-            if (!valid) {
-                debugWarn(`[Node] Invalid BuyerAck signature from ${buyerPeerId.slice(0, 12)}...`);
-                return;
-            }
-            session.ackedRequestCount = payload.requestCount;
-            session.lastAckedTotal = BigInt(payload.runningTotal);
-            session.awaitingAck = false;
-            debugLog(`[Node] BuyerAck received: requestCount=${payload.requestCount} runningTotal=${payload.runningTotal}`);
-        }
-        catch (err) {
-            debugWarn(`[Node] Failed to process BuyerAck: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    /**
-     * Handle SessionEnd from buyer (Task 5).
-     * Submits settlement on-chain and cleans up.
-     */
-    async _handleSessionEnd(buyerPeerId, payload) {
-        const session = this._sessions.get(buyerPeerId);
-        if (!session || !session.lockCommitted) {
-            debugWarn(`[Node] Received SessionEnd for unknown/uncommitted session from ${buyerPeerId.slice(0, 12)}...`);
-            return;
-        }
-        if (!this._identity || !this._escrowClient) {
-            debugWarn(`[Node] Cannot process SessionEnd — escrow client not available`);
-            return;
-        }
-        try {
-            const sellerWallet = identityToEvmWallet(this._identity);
-            const sessionIdHex = "0x" + bytesToHex(session.sessionIdBytes);
-            // Submit settlement on-chain with buyer's ECDSA signature and score
-            const txHash = await this._escrowClient.settle(sellerWallet, sessionIdHex, BigInt(payload.runningTotal), payload.score, payload.buyerSig);
-            debugLog(`[Node] Session settled on-chain: ${session.sessionId.slice(0, 8)}... tx=${txHash.slice(0, 12)}... score=${payload.score}`);
-            // Clean up session
-            this._sessions.delete(buyerPeerId);
-            const timer = this._settlementTimers.get(buyerPeerId);
-            if (timer) {
-                clearTimeout(timer);
-                this._settlementTimers.delete(buyerPeerId);
-            }
-            this.emit("session:settled", {
-                buyerPeerId,
-                sessionId: session.sessionId,
-                runningTotal: payload.runningTotal,
-                score: payload.score,
-                txHash,
-            });
-        }
-        catch (err) {
-            debugWarn(`[Node] Failed to settle session ${session.sessionId}: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    /**
-     * Handle TopUpAuth from buyer (Task 6).
-     * Calls extendLock on-chain and updates session.
-     */
-    async _handleTopUpAuth(buyerPeerId, payload) {
-        const session = this._sessions.get(buyerPeerId);
-        if (!session || !session.lockCommitted) {
-            debugWarn(`[Node] Received TopUpAuth for unknown/uncommitted session from ${buyerPeerId.slice(0, 12)}...`);
-            return;
-        }
-        if (!this._identity || !this._escrowClient) {
-            debugWarn(`[Node] Cannot process TopUpAuth — escrow client not available`);
-            return;
-        }
-        try {
-            const sellerWallet = identityToEvmWallet(this._identity);
-            const sessionIdHex = "0x" + bytesToHex(session.sessionIdBytes);
-            const additionalAmount = BigInt(payload.additionalAmount);
-            const txHash = await this._escrowClient.extendLock(sellerWallet, sessionIdHex, additionalAmount, payload.buyerSig);
-            session.lockedAmount += additionalAmount;
-            debugLog(`[Node] TopUp committed: session=${session.sessionId.slice(0, 8)}... additional=${additionalAmount} newTotal=${session.lockedAmount} tx=${txHash.slice(0, 12)}...`);
-        }
-        catch (err) {
-            debugWarn(`[Node] Failed to extend lock for session ${session.sessionId}: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    // ── Buyer-side payment helpers ─────────────────────────────────
-    /**
-     * Create a PaymentMux for a buyer-side outbound connection and register
-     * buyer-side handlers (lock confirm, lock reject, seller receipt, top-up request).
-     */
-    _getOrCreateBuyerPaymentMux(peerId, conn) {
-        const existing = this._paymentMuxes.get(peerId);
-        if (existing)
-            return existing;
-        const pmux = new PaymentMux(conn);
-        this._paymentMuxes.set(peerId, pmux);
-        const bpm = this._buyerPaymentManager;
-        if (!bpm)
-            return pmux;
-        pmux.onSessionLockConfirm((payload) => {
-            bpm.handleLockConfirm(peerId, payload);
-        });
-        pmux.onSessionLockReject((payload) => {
-            bpm.handleLockReject(peerId, payload);
-        });
-        pmux.onSellerReceipt((receipt) => {
-            void bpm.handleSellerReceipt(peerId, receipt, pmux);
-        });
-        pmux.onTopUpRequest((request) => {
-            void bpm.handleTopUpRequest(peerId, request, pmux);
-        });
-        return pmux;
-    }
-    /**
-     * Initiate a lock with a seller peer. Creates PaymentMux, signs lock auth,
-     * and waits for confirmation before returning.
-     */
-    async _initiateBuyerLock(peer, conn) {
-        const bpm = this._buyerPaymentManager;
-        if (!bpm)
-            return;
-        // Mark as locked so we don't re-initiate
-        this._buyerLockedPeers.add(peer.peerId);
-        const pmux = this._getOrCreateBuyerPaymentMux(peer.peerId, conn);
-        // Determine seller EVM address — prefer from peer metadata
-        const sellerEvmAddress = peer.evmAddress ?? "";
-        if (!sellerEvmAddress) {
-            debugWarn(`[Node] Seller ${peer.peerId.slice(0, 12)}... has no EVM address; skipping lock initiation`);
-            return;
-        }
-        try {
-            await bpm.initiateLock(peer.peerId, sellerEvmAddress, pmux);
-            debugLog(`[Node] Lock initiated for seller ${peer.peerId.slice(0, 12)}..., waiting for confirmation...`);
-            // Wait for lock confirmation (polls every 200ms, 30s timeout)
-            await this._waitForLockConfirmation(peer.peerId);
-            debugLog(`[Node] Lock confirmed for seller ${peer.peerId.slice(0, 12)}...`);
-        }
-        catch (err) {
-            debugWarn(`[Node] Lock initiation/confirmation failed for ${peer.peerId.slice(0, 12)}...: ${err instanceof Error ? err.message : err}`);
-            // Remove from locked set so next request can retry
-            this._buyerLockedPeers.delete(peer.peerId);
-        }
-    }
-    /**
-     * Poll until the lock for a seller is confirmed or rejected.
-     * Polls every 200ms with a 30-second timeout.
-     */
-    async _waitForLockConfirmation(sellerPeerId) {
-        const bpm = this._buyerPaymentManager;
-        if (!bpm)
-            return;
-        const pollIntervalMs = 200;
-        const timeoutMs = 30_000;
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (bpm.isLockConfirmed(sellerPeerId)) {
-                return;
-            }
-            if (bpm.isLockRejected(sellerPeerId)) {
-                throw new Error(`Lock rejected by seller ${sellerPeerId.slice(0, 12)}...`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-        }
-        throw new Error(`Lock confirmation timed out for seller ${sellerPeerId.slice(0, 12)}... (${timeoutMs}ms)`);
-    }
-    /**
-     * End all active buyer payment sessions (called during shutdown).
-     */
-    async _endAllBuyerSessions() {
-        const bpm = this._buyerPaymentManager;
-        if (!bpm)
-            return;
-        const sessions = bpm.getActiveSessions();
-        if (sessions.length === 0)
-            return;
-        debugLog(`[Node] Ending ${sessions.length} buyer payment session(s)...`);
-        await Promise.allSettled(sessions.map((session) => {
-            const pmux = this._paymentMuxes.get(session.sellerPeerId);
-            if (pmux) {
-                return bpm.endSession(session.sellerPeerId, pmux, 80);
-            }
-            return Promise.resolve();
-        }));
-    }
     _resolvePublicAddress(result) {
         const metadataPublicAddress = result.metadata.publicAddress?.trim();
         if (metadataPublicAddress && parsePublicAddress(metadataPublicAddress) !== null) {
@@ -1576,59 +909,13 @@ export class AntseedNode extends EventEmitter {
             defaultOutputUsdPerMillion: firstProvider?.defaultPricing.outputUsdPerMillion,
             maxConcurrency: firstProvider?.maxConcurrency,
             currentLoad: firstProvider?.currentLoad,
-            evmAddress: result.metadata.evmAddress,
-            onChainReputation: result.metadata.onChainReputation,
-            onChainSessionCount: result.metadata.onChainSessionCount,
-            onChainDisputeCount: result.metadata.onChainDisputeCount,
-            trustScore: result.metadata.onChainReputation,
+            onChainChannelCount: result.metadata.onChainChannelCount,
+            onChainGhostCount: result.metadata.onChainGhostCount,
         };
     }
-    _adjustProviderLoad(providerName, delta) {
-        const nextLoad = Math.max(0, (this._providerLoadCounts.get(providerName) ?? 0) + delta);
-        this._providerLoadCounts.set(providerName, nextLoad);
-        if (!this._announcer)
-            return;
-        this._announcer.updateLoad(providerName, nextLoad);
-        this._scheduleMetadataRefresh();
-    }
-    _scheduleMetadataRefresh() {
-        if (!this._announcer || this._metadataRefreshTimer) {
-            return;
-        }
-        const timer = setTimeout(() => {
-            this._metadataRefreshTimer = null;
-            const announcer = this._announcer;
-            if (!announcer)
-                return;
-            void announcer.refreshMetadata().catch((err) => {
-                debugWarn(`[Node] Failed to refresh metadata snapshot: ${err instanceof Error ? err.message : err}`);
-            });
-        }, AntseedNode._METADATA_REFRESH_DEBOUNCE_MS);
-        this._metadataRefreshTimer = timer;
-        this._unrefTimer(timer);
-    }
-    _unrefTimer(timer) {
-        if (typeof timer.unref === "function") {
-            timer.unref();
-        }
-    }
 }
 function parsePeerAddress(address) {
     const parts = address.split(":");
     return { host: parts[0], port: parseInt(parts[1] ?? "6882", 10) };
 }
-function concatChunks(chunks) {
-    if (chunks.length === 0)
-        return new Uint8Array(0);
-    if (chunks.length === 1)
-        return chunks[0];
-    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const output = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        output.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return output;
-}
 //# sourceMappingURL=node.js.map