@antseed/node 0.2.27 → 0.2.28

package/dist/node.js

@@ -1,12 +1,11 @@
 import { EventEmitter } from "node:events";
-import { createHash, randomUUID } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadOrCreateIdentity } from "./p2p/identity.js";
-import { ANTSEED_STREAMING_RESPONSE_HEADER, ANTSEED_SPENDING_AUTH_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";
@@ -20,61 +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";
-// verifyMessage/getBytes removed — no longer needed after SpendingAuth refactor
-import { BalanceManager, BaseEscrowClient, SessionStore, } from "./payments/index.js";
-import { parseJsonObject, extractUsage } from "@antseed/api-adapter";
+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 { BuyerPaymentNegotiator } from "./payments/buyer-payment-negotiator.js";
 import { SellerPaymentManager } from "./payments/seller-payment-manager.js";
-import { identityToEvmAddress } from "./payments/evm/keypair.js";
 import { IdentityClient } from "./payments/evm/identity-client.js";
-import { verifyReputation } from "./discovery/reputation-verifier.js";
-/**
- * Extract actual token usage from an LLM provider response body.
- * Handles both JSON and SSE (streaming) responses. Returns zeros
- * if usage data is not found (caller should fall back to estimation).
- */
-function parseResponseUsage(body) {
-    const parsed = parseJsonObject(body);
-    if (parsed) {
-        return extractUsage(parsed);
-    }
-    // SSE streaming: scan data lines for a usage object
-    const text = new TextDecoder().decode(body);
-    let inputTokens = 0;
-    let outputTokens = 0;
-    for (const line of text.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('data:'))
-            continue;
-        const payload = trimmed.slice(5).trim();
-        if (!payload || payload === '[DONE]')
-            continue;
-        try {
-            const event = JSON.parse(payload);
-            const usage = extractUsage(event);
-            if (usage.inputTokens > 0)
-                inputTokens = Math.max(inputTokens, usage.inputTokens);
-            if (usage.outputTokens > 0)
-                outputTokens = Math.max(outputTokens, usage.outputTokens);
-        }
-        catch { /* skip non-JSON lines */ }
-    }
-    return { inputTokens, outputTokens };
-}
-function parsePaymentRequiredBody(body) {
-    try {
-        const parsed = JSON.parse(new TextDecoder().decode(body));
-        return parsed && typeof parsed === "object" ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
+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;
@@ -91,33 +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;
+    /** 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 session store for payment persistence. */
-    _sessionStore = null;
+    /** Shared channel store for payment persistence. */
+    _channelStore = null;
     /** Periodic timeout checker interval. */
     _timeoutCheckerInterval = null;
-    /** Tracks which seller peers the buyer has already negotiated payment for. */
-    _buyerLockedPeers = new Set();
-    /** Pending PaymentRequired payloads from sellers, keyed by peerId. Resolvers waiting for them. */
-    _pendingPaymentRequired = new Map();
-    _manualApprovalCache = null;
-    /** Buffered PaymentRequired that arrived before _doNegotiatePayment registered its listener.
-     *  This handles the race where 402 + PaymentRequired arrive in the same I/O tick. */
-    _bufferedPaymentRequired = new Map();
-    /** Per-peer mutex to prevent concurrent payment negotiations. */
-    _paymentNegotiationLocks = new Map();
-    /** Peers the caller has manually approved by retrying after a 402. */
+    /** Block cursor for CloseRequested event polling. */
+    _closeRequestedFromBlock = 0;
+    /** Seller session lifecycle tracking (metering, settlement). */
+    _sessionTracker = null;
     constructor(config) {
         super();
         this._config = config;
@@ -141,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;
@@ -149,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;
@@ -158,31 +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),
-            });
-        }
-        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) {
@@ -213,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();
+        }
+        if (this._sessionTracker) {
+            await this._sessionTracker.finalizeAllSessions("node-stop");
+            this._sessionTracker.clearTimers();
         }
-        this._settlementTimers.clear();
-        if (this._metadataRefreshTimer) {
-            clearTimeout(this._metadataRefreshTimer);
-            this._metadataRefreshTimer = null;
+        if (this._sellerHandler) {
+            this._sellerHandler.clearMetadataRefreshTimer();
+            this._sellerHandler = null;
         }
-        this._providerLoadCounts.clear();
         // Remove NAT port mappings
         if (this._nat) {
             await this._nat.cleanup();
@@ -275,31 +214,27 @@ export class AntseedNode extends EventEmitter {
             clearInterval(this._timeoutCheckerInterval);
             this._timeoutCheckerInterval = null;
         }
-        if (this._sessionStore) {
+        if (this._channelStore) {
             try {
-                this._sessionStore.close();
+                this._channelStore.close();
             }
             catch {
                 // ignore close errors
             }
-            this._sessionStore = null;
+            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._buyerNegotiator = null;
+        this._buyerHandler = null;
         this._sellerPaymentManager = null;
-        this._buyerLockedPeers.clear();
-        // Clean up payment negotiation state
-        for (const [, pending] of this._pendingPaymentRequired) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error('Node stopped'));
-        }
-        this._pendingPaymentRequired.clear();
-        this._bufferedPaymentRequired.clear();
-        this._paymentNegotiationLocks.clear();
+        this._sessionTracker = null;
         this._started = false;
         this.emit("stopped");
     }
@@ -328,31 +263,18 @@ export class AntseedNode extends EventEmitter {
                 peers.push(p);
             }
         }
-        // Optional reputation verification: replace claimed data with verified on-chain data
-        if (this._identityClient) {
+        // Verify claimed on-chain stats against actual contract data
+        if (this._channelsClient && this._stakingClient) {
             for (const p of peers) {
-                if (!p.evmAddress)
-                    continue;
                 try {
-                    const metadata = {
-                        peerId: p.peerId,
-                        version: 0,
-                        providers: [],
-                        region: "",
-                        timestamp: 0,
-                        signature: "",
-                        evmAddress: p.evmAddress,
-                        onChainReputation: p.onChainReputation,
-                        onChainSessionCount: p.onChainSessionCount,
-                        onChainDisputeCount: p.onChainDisputeCount,
-                    };
-                    const result = await verifyReputation(this._identityClient, metadata);
-                    p.onChainReputation = result.actualReputation;
-                    p.onChainSessionCount = result.actualSessionCount;
-                    p.onChainDisputeCount = result.actualDisputeCount;
+                    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 {
-                    // Identity contract lookup failed for this peer — keep claimed data
+                    // Contract lookup failed for this peer — keep claimed data
                 }
             }
         }
@@ -368,285 +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);
-        // Extract and strip x-antseed-spending-auth header if present (manual approval flow)
-        const externalSpendingAuth = req.headers[ANTSEED_SPENDING_AUTH_HEADER] ?? null;
-        if (externalSpendingAuth) {
-            const { [ANTSEED_SPENDING_AUTH_HEADER]: _, ...cleanHeaders } = req.headers;
-            req = { ...req, headers: cleanHeaders };
-        }
-        // If we already have a payment session with this peer, skip negotiation.
-        const needsPaymentNegotiation = this._buyerPaymentManager
-            && !this._buyerLockedPeers.has(peer.peerId);
-        // If an external spending auth was provided, apply it before sending the request.
-        if (externalSpendingAuth && needsPaymentNegotiation) {
-            debugLog(`[Node] Applying external spending auth for ${peer.peerId.slice(0, 12)}...`);
-            await this._applyExternalSpendingAuth(peer, conn, externalSpendingAuth);
-        }
-        const startTime = Date.now();
-        const executeRequest = () => 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),
-                });
-            });
-        });
-        // Execute the request. If we get a 402 and payment negotiation is needed,
-        // wait for the seller's PaymentRequired message, negotiate, and retry.
-        const response = await executeRequest();
-        if (response.statusCode === 402 && needsPaymentNegotiation && !externalSpendingAuth) {
-            const manualApproval = await this._isManualApprovalEnabled();
-            const directPaymentBody = parsePaymentRequiredBody(response.body);
-            const responseAlreadyHasRequirements = Boolean(directPaymentBody?.sellerEvmAddr);
-            const waitMs = manualApproval ? 10_000 : 2_000;
-            const buffered = responseAlreadyHasRequirements
-                ? null
-                : await this._awaitPaymentRequired(peer.peerId, conn, waitMs);
-            if (buffered)
-                this._bufferedPaymentRequired.delete(peer.peerId);
-            // Helper: return enriched 402 so the caller can show an approval / add-credits card
-            const returnPaymentRequired = (reason) => {
-                debugLog(`[Node] Got 402 from ${peer.peerId.slice(0, 12)}... — returning to caller (${reason})`);
-                if (responseAlreadyHasRequirements) {
-                    return response;
-                }
-                if (buffered) {
-                    const enrichedBody = JSON.stringify({
-                        error: 'payment_required',
-                        peerId: peer.peerId,
-                        sellerEvmAddr: buffered.sellerEvmAddr,
-                        tokenRate: buffered.tokenRate,
-                        firstSignCap: buffered.firstSignCap,
-                        suggestedAmount: buffered.suggestedAmount,
-                    });
-                    return {
-                        ...response,
-                        headers: { ...response.headers, 'content-type': 'application/json' },
-                        body: new TextEncoder().encode(enrichedBody),
-                    };
-                }
-                return response;
-            };
-            // If manual approval is on, always return the 402 to the caller
-            if (manualApproval) {
-                return returnPaymentRequired(responseAlreadyHasRequirements ? 'manual approval (direct body)' : 'manual approval');
-            }
-            // Auto mode: check if we can actually pay before attempting negotiation
-            if (!this._escrowClient || !this._identity || !this._buyerPaymentManager) {
-                return returnPaymentRequired('no escrow configured');
-            }
-            // Check on-chain balance — if insufficient, return 402 instead of failing mid-negotiate
-            try {
-                const buyerAddr = identityToEvmAddress(this._identity);
-                const balance = await this._escrowClient.getBuyerBalance(buyerAddr);
-                if (balance.available <= 0n) {
-                    return returnPaymentRequired('insufficient credits');
-                }
-            }
-            catch (err) {
-                debugWarn(`[Node] Failed to check buyer balance: ${err instanceof Error ? err.message : err}`);
-                // Fall through to negotiate — let it fail naturally if balance is truly insufficient
-            }
-            // Auto-negotiate: sign SpendingAuth internally and retry
-            // Re-buffer the PaymentRequired so _doNegotiatePayment can consume it
-            if (buffered)
-                this._bufferedPaymentRequired.set(peer.peerId, buffered);
-            debugLog(`[Node] Got 402 from ${peer.peerId.slice(0, 12)}... — auto-negotiating payment`);
-            try {
-                await this._negotiatePayment(peer, conn);
-                debugLog(`[Node] Payment negotiated with ${peer.peerId.slice(0, 12)}... — retrying request`);
-                return executeRequest();
-            }
-            catch (err) {
-                this._buyerLockedPeers.delete(peer.peerId);
-                throw err;
-            }
-        }
-        return response;
+        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 {
@@ -719,24 +420,16 @@ export class AntseedNode extends EventEmitter {
                 this._muxes.get(peerId)?.abortPendingUploads();
                 this._muxes.delete(peerId);
                 this._paymentMuxes.delete(peerId);
-                this._bufferedPaymentRequired.delete(peerId);
-                // Cancel any in-flight PaymentRequired wait so _doNegotiatePayment
-                // fails immediately instead of blocking for 10s on a dead connection.
-                const pendingPR = this._pendingPaymentRequired.get(peerId);
-                if (pendingPR) {
-                    clearTimeout(pendingPR.timer);
-                    this._pendingPaymentRequired.delete(peerId);
-                    pendingPR.reject(new Error(`Peer ${peerId.slice(0, 12)}... disconnected during payment negotiation`));
-                }
-                // Don't delete _paymentNegotiationLocks here — the pending rejection
-                // causes _doNegotiatePayment to throw, and its finally block owns cleanup.
-                // Deleting here would race with a new negotiation started on reconnect.
                 this._decoders.delete(peerId);
-                // Handle buyer 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);
                 }
-                void this._finalizeSession(peerId, "disconnect");
+                if (this._sessionTracker) {
+                    void this._sessionTracker.finalizeSession(peerId, "disconnect");
+                }
             }
         });
         // Start keepalive pings on outbound (buyer-initiated) connections to
@@ -769,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"));
@@ -781,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();
@@ -843,13 +550,23 @@ export class AntseedNode extends EventEmitter {
                 ])),
                 reannounceIntervalMs: DEFAULT_DHT_CONFIG.reannounceIntervalMs,
                 signalingPort: actualSignalingPort,
-                ...(this._identityClient ? { identityClient: this._identityClient } : {}),
+                ...(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);
@@ -884,460 +601,161 @@ 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) {
+        if (payments?.enabled && payments.rpcUrl && payments.depositsAddress && payments.channelsAddress && payments.usdcAddress) {
             const paymentsDir = join(dataDir, "payments");
-            // Create shared SessionStore for both buyer and seller payment managers
-            if (!this._sessionStore) {
+            // Create shared ChannelStore for both buyer and seller payment managers
+            if (!this._channelStore) {
                 try {
-                    this._sessionStore = new SessionStore(paymentsDir);
-                    debugLog("[Node] SessionStore initialized (buyer)");
+                    this._channelStore = new ChannelStore(paymentsDir);
+                    debugLog("[Node] ChannelStore initialized (buyer)");
                 }
                 catch (err) {
-                    debugWarn(`[Node] SessionStore unavailable: ${err instanceof Error ? err.message : err}`);
+                    debugWarn(`[Node] ChannelStore unavailable: ${err instanceof Error ? err.message : err}`);
                 }
             }
-            if (this._sessionStore) {
+            if (this._channelStore) {
                 const buyerPaymentConfig = {
                     rpcUrl: payments.rpcUrl,
-                    contractAddress: payments.contractAddress,
+                    depositsContractAddress: payments.depositsAddress,
+                    channelsContractAddress: payments.channelsAddress,
                     usdcAddress: payments.usdcAddress,
-                    identityAddress: payments.identityAddress ?? '',
+                    identityRegistryAddress: payments.identityRegistryAddress ?? '',
                     chainId: payments.chainId ?? 8453,
-                    defaultMaxAmountUsdc: BigInt(payments.defaultMaxAmountUsdc ?? "1000000"),
-                    defaultAuthDurationSecs: payments.defaultAuthDurationSecs ?? 90000, // Must exceed SETTLE_TIMEOUT (24h)
-                    autoAck: payments.autoAck ?? true,
+                    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._sessionStore);
-                debugLog(`[Node] Buyer payment manager initialized (wallet=${identityToEvmAddress(identity).slice(0, 10)}... chainId=${buyerPaymentConfig.chainId} contract=${buyerPaymentConfig.contractAddress.slice(0, 10)}...)`);
-            }
-        }
+                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);
         if (this._sellerPaymentManager) {
             const spm = this._sellerPaymentManager;
             paymentMux.onSpendingAuth((payload) => {
-                void spm.handleSpendingAuth(buyerPeerId, payload.buyerEvmAddr, payload, paymentMux);
-            });
-            paymentMux.onBuyerAck((payload) => {
-                void spm.handleBuyerAck(buyerPeerId, 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' });
+                    }
+                })
+                    .catch((err) => {
+                    debugWarn(`[Node] SpendingAuth handler error for ${buyerPeerId.slice(0, 12)}...: ${err instanceof Error ? err.message : err}`);
+                });
             });
         }
         else {
-            // No SellerPaymentManager — reject SpendingAuth to prevent
-            // accepting payment claims without EIP-712 signature verification
             paymentMux.onSpendingAuth(() => {
                 debugWarn(`[Node] SpendingAuth rejected — SellerPaymentManager not configured`);
             });
         }
         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 no active payment session and escrow client is configured.
-            // Also send PaymentRequired via PaymentMux so the buyer knows what to sign.
-            const spmAuthorized = this._sellerPaymentManager?.hasSession(buyerPeerId) ?? false;
-            if (this._escrowClient && !spmAuthorized) {
-                // Pass buyerPeerId so seller can suggest higher amount for returning buyers,
-                // and include per-direction pricing from the first registered provider.
-                // Retry init if it failed at startup (e.g. RPC was unreachable)
-                await this._sellerPaymentManager?.ensureInitialized();
-                const firstProvider = this._providers[0];
-                const providerPricing = firstProvider?.pricing?.defaults;
-                const requirements = this._sellerPaymentManager?.getPaymentRequirements(request.requestId, buyerPeerId, providerPricing);
-                if (requirements) {
-                    debugLog(`[Node] No payment session for ${buyerPeerId.slice(0, 12)}... — sending 402 + PaymentRequired`);
-                    const paymentBody = JSON.stringify({
-                        error: 'payment_required',
-                        sellerEvmAddr: requirements.sellerEvmAddr,
-                        tokenRate: requirements.tokenRate,
-                        firstSignCap: requirements.firstSignCap,
-                        suggestedAmount: requirements.suggestedAmount,
-                    });
-                    mux.sendProxyResponse({
-                        requestId: request.requestId,
-                        statusCode: 402,
-                        headers: { "content-type": "application/json" },
-                        body: new TextEncoder().encode(paymentBody),
-                    });
-                    paymentMux.sendPaymentRequired(requirements);
-                }
-                else {
-                    // init() failed — on-chain data not cached. Tell buyer to retry
-                    // rather than letting them wait 10s for a PaymentRequired that won't come.
-                    debugWarn(`[Node] No payment session and seller not ready (init failed?) — returning 402`);
-                    mux.sendProxyResponse({
-                        requestId: request.requestId,
-                        statusCode: 402,
-                        headers: { "content-type": "application/json" },
-                        body: new TextEncoder().encode(JSON.stringify({
-                            error: 'payment_required',
-                            message: 'Seller not ready, try again later',
-                        })),
-                    });
-                }
-                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,
-                        });
-                    }
-                }
-                // 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, responseBody);
-                // Send receipt to buyer after each request
-                if (this._sellerPaymentManager?.hasSession(buyerPeerId)) {
-                    const usage = parseResponseUsage(responseBody);
-                    const totalTokens = usage.inputTokens + usage.outputTokens;
-                    debugLog(`[Node] Sending receipt: buyer=${buyerPeerId.slice(0, 12)}... tokens=${totalTokens} (in=${usage.inputTokens} out=${usage.outputTokens})`);
-                    await this._sellerPaymentManager.sendReceipt(buyerPeerId, paymentMux, responseBody, BigInt(totalTokens));
-                }
-            }
-            finally {
-                this._adjustProviderLoad(provider.name, -1);
-            }
-        });
+        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,
-            };
-            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). */
-    /** Fallback token estimation from byte lengths (~4 bytes 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, method: 'content-length', confidence: 'low' };
-    }
-    async _recordMetering(buyerPeerId, providerName, providerPricingUsdPerMillion, request, statusCode, latencyMs, inputBytes, outputBytes, responseBody) {
-        if (!this._identity)
-            return;
-        const sellerPeerId = this._identity.peerId;
-        const isSSE = request.headers["accept"]?.includes("text/event-stream") ?? false;
-        // Use actual token counts from provider response when available,
-        // falling back to byte-based estimation.
-        const providerUsage = parseResponseUsage(responseBody);
-        let tokens;
-        if (providerUsage.inputTokens > 0 || providerUsage.outputTokens > 0) {
-            const totalTokens = providerUsage.inputTokens + providerUsage.outputTokens;
-            tokens = {
-                inputTokens: providerUsage.inputTokens,
-                outputTokens: providerUsage.outputTokens,
-                totalTokens,
-                method: 'provider-usage',
-                confidence: 'high',
-            };
-            debugLog(`[Node] Metering: provider-usage tokens=${totalTokens} (in=${providerUsage.inputTokens} out=${providerUsage.outputTokens})`);
-        }
-        else {
-            tokens = this._estimateTokens(inputBytes, outputBytes);
-            debugLog(`[Node] Metering: estimated tokens=${tokens.totalTokens} from ${inputBytes}+${outputBytes} bytes`);
-        }
-        // 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.depositsAddress,
+                usdcAddress: payments.usdcAddress,
+            });
+            debugLog(`[Node] DepositsClient initialized (contract=${payments.depositsAddress.slice(0, 10)}...)`);
+        }
+        // Initialize ChannelsClient
+        if (payments.rpcUrl && payments.channelsAddress) {
+            this._channelsClient = new ChannelsClient({
                 rpcUrl: payments.rpcUrl,
-                contractAddress: payments.contractAddress,
+                contractAddress: payments.channelsAddress,
+            });
+            debugLog(`[Node] ChannelsClient initialized (contract=${payments.channelsAddress.slice(0, 10)}...)`);
+        }
+        // Initialize StakingClient
+        if (payments.rpcUrl && payments.stakingAddress && payments.usdcAddress) {
+            this._stakingClient = new StakingClient({
+                rpcUrl: payments.rpcUrl,
+                contractAddress: payments.stakingAddress,
                 usdcAddress: payments.usdcAddress,
             });
-            debugLog(`[Node] BaseEscrowClient initialized (contract=${payments.contractAddress.slice(0, 10)}...)`);
+            debugLog(`[Node] StakingClient initialized (contract=${payments.stakingAddress.slice(0, 10)}...)`);
         }
-        // Initialize IdentityClient if identity contract address is provided
-        if (payments.rpcUrl && payments.identityAddress) {
+        // Initialize IdentityClient (ERC-8004 IdentityRegistry)
+        if (payments.rpcUrl && payments.identityRegistryAddress) {
             this._identityClient = new IdentityClient({
                 rpcUrl: payments.rpcUrl,
-                contractAddress: payments.identityAddress,
+                contractAddress: payments.identityRegistryAddress,
             });
-            debugLog(`[Node] IdentityClient initialized (contract=${payments.identityAddress.slice(0, 10)}...)`);
+            debugLog(`[Node] IdentityClient initialized (contract=${payments.identityRegistryAddress.slice(0, 10)}...)`);
         }
-        // Initialize SessionStore for persistent payment sessions (shared instance)
+        // Initialize ChannelStore for persistent payment channels (shared instance)
         const paymentsDir = join(dataDir, "payments");
-        if (!this._sessionStore) {
+        if (!this._channelStore) {
             try {
-                this._sessionStore = new SessionStore(paymentsDir);
-                debugLog("[Node] SessionStore initialized");
+                this._channelStore = new ChannelStore(paymentsDir);
+                debugLog("[Node] ChannelStore initialized");
             }
             catch (err) {
-                debugWarn(`[Node] SessionStore unavailable: ${err instanceof Error ? err.message : err}`);
+                debugWarn(`[Node] ChannelStore unavailable: ${err instanceof Error ? err.message : err}`);
             }
         }
         // Initialize SellerPaymentManager for seller role
-        if (this._config.role === 'seller' && this._identity && this._sessionStore &&
-            payments.rpcUrl && payments.contractAddress && payments.usdcAddress) {
+        if (this._config.role === 'seller' && this._identity && this._channelStore &&
+            payments.rpcUrl && payments.channelsAddress) {
             const sellerConfig = {
                 rpcUrl: payments.rpcUrl,
-                contractAddress: payments.contractAddress,
-                usdcAddress: payments.usdcAddress,
+                channelsContractAddress: payments.channelsAddress,
                 chainId: payments.chainId ?? 8453,
                 dataDir: paymentsDir,
-                firstSignAmountUsdc: payments.firstSignAmountUsdc,
-                provenSignAmountUsdc: payments.provenSignAmountUsdc,
+                ...(payments.minBudgetPerRequest ? { minBudgetPerRequest: payments.minBudgetPerRequest } : {}),
             };
-            this._sellerPaymentManager = new SellerPaymentManager(this._identity, sellerConfig, this._sessionStore);
-            await this._sellerPaymentManager.init();
+            this._sellerPaymentManager = new SellerPaymentManager(this._identity, sellerConfig, this._channelStore);
             debugLog(`[Node] SellerPaymentManager initialized`);
             // Startup recovery: check for timed-out sessions
             await this._sellerPaymentManager.checkTimeouts();
-            // Start periodic timeout checker (every 60s)
+            // 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();
@@ -1352,77 +770,6 @@ export class AntseedNode extends EventEmitter {
             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();
-        }
-        this._settlementTimers.set(buyerPeerId, timer);
-    }
-    async _finalizeSession(buyerPeerId, reason) {
-        const session = this._sessions.get(buyerPeerId);
-        if (!session || session.settling) {
-            return;
-        }
-        session.settling = true;
-        const timer = this._settlementTimers.get(buyerPeerId);
-        if (timer) {
-            clearTimeout(timer);
-            this._settlementTimers.delete(buyerPeerId);
-        }
-        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();
-            }
-            this._settlementTimers.set(buyerPeerId, retry);
-        }
-    }
-    async _finalizeAllSessions(reason) {
-        if (this._sessions.size === 0)
-            return;
-        const buyers = [...this._sessions.keys()];
-        await Promise.allSettled(buyers.map((buyerPeerId) => this._finalizeSession(buyerPeerId, reason)));
-    }
     async _getOrCreateConnection(peer) {
         if (!this._connectionManager || !this._identity) {
             throw new Error("Node not started");
@@ -1507,336 +854,6 @@ export class AntseedNode extends EventEmitter {
         this._muxes.set(peerId, mux);
         return mux;
     }
-    // ── 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.onAuthAck((payload) => {
-            bpm.handleAuthAck(peerId, payload);
-        });
-        pmux.onSellerReceipt((receipt) => {
-            void bpm.handleSellerReceipt(peerId, receipt, pmux);
-        });
-        pmux.onTopUpRequest((request) => {
-            void bpm.handleTopUpRequest(peerId, request, pmux);
-        });
-        pmux.onPaymentRequired((payload) => {
-            const pending = this._pendingPaymentRequired.get(peerId);
-            if (pending) {
-                clearTimeout(pending.timer);
-                this._pendingPaymentRequired.delete(peerId);
-                pending.resolve(payload);
-            }
-            else {
-                // Buffer: 402 and PaymentRequired can arrive in the same I/O tick,
-                // before _doNegotiatePayment registers its listener.
-                this._bufferedPaymentRequired.set(peerId, payload);
-                debugLog(`[Node] PaymentRequired from ${peerId.slice(0, 12)}... buffered (listener not yet registered)`);
-            }
-        });
-        return pmux;
-    }
-    /**
-     * Wait for the seller's PaymentRequired message, sign a SpendingAuth with
-     * the seller's real requirements, and wait for AuthAck.
-     * Uses a per-peer mutex so concurrent requests wait for the first negotiation.
-     */
-    /** Read requireManualApproval from config.json so changes take effect without restart. */
-    async _isManualApprovalEnabled() {
-        const now = Date.now();
-        if (this._manualApprovalCache && now - this._manualApprovalCache.at < 5_000) {
-            return this._manualApprovalCache.value;
-        }
-        try {
-            const configPath = this._config.configPath
-                ?? join(this._config.dataDir ?? join(homedir(), '.antseed'), 'config.json');
-            const raw = await readFile(configPath, 'utf-8');
-            const parsed = JSON.parse(raw);
-            const buyer = parsed.buyer && typeof parsed.buyer === 'object' ? parsed.buyer : {};
-            const value = Boolean(buyer.requireManualApproval);
-            this._manualApprovalCache = { value, at: now };
-            return value;
-        }
-        catch {
-            const value = Boolean(this._config.requireManualApproval);
-            this._manualApprovalCache = { value, at: now };
-            return value;
-        }
-    }
-    /**
-     * Wait for the seller's PaymentRequired payload for a given peer.
-     * Returns a buffered payload immediately when available, otherwise waits up to timeoutMs.
-     */
-    async _awaitPaymentRequired(peerId, conn, timeoutMs) {
-        const buffered = this._bufferedPaymentRequired.get(peerId);
-        if (buffered) {
-            return buffered;
-        }
-        // Ensure the buyer-side PaymentMux exists before waiting so incoming frames
-        // are captured even when 402 and PaymentRequired arrive close together.
-        this._getOrCreateBuyerPaymentMux(peerId, conn);
-        return await new Promise((resolve) => {
-            const already = this._bufferedPaymentRequired.get(peerId);
-            if (already) {
-                resolve(already);
-                return;
-            }
-            const existing = this._pendingPaymentRequired.get(peerId);
-            if (existing) {
-                const wrapper = {
-                    resolve: (payload) => {
-                        clearTimeout(existing.timer);
-                        clearTimeout(wrapper.timer);
-                        if (this._pendingPaymentRequired.get(peerId) === wrapper) {
-                            this._pendingPaymentRequired.delete(peerId);
-                        }
-                        existing.resolve(payload);
-                        resolve(payload);
-                    },
-                    reject: (err) => {
-                        clearTimeout(existing.timer);
-                        clearTimeout(wrapper.timer);
-                        if (this._pendingPaymentRequired.get(peerId) === wrapper) {
-                            this._pendingPaymentRequired.delete(peerId);
-                        }
-                        existing.reject(err);
-                        resolve(null);
-                    },
-                    timer: setTimeout(() => {
-                        clearTimeout(existing.timer);
-                        if (this._pendingPaymentRequired.get(peerId) === wrapper) {
-                            this._pendingPaymentRequired.delete(peerId);
-                        }
-                        resolve(null);
-                    }, timeoutMs),
-                };
-                this._pendingPaymentRequired.set(peerId, wrapper);
-                return;
-            }
-            const timer = setTimeout(() => {
-                if (this._pendingPaymentRequired.get(peerId)?.timer === timer) {
-                    this._pendingPaymentRequired.delete(peerId);
-                }
-                resolve(null);
-            }, timeoutMs);
-            this._pendingPaymentRequired.set(peerId, {
-                resolve: (payload) => {
-                    clearTimeout(timer);
-                    if (this._pendingPaymentRequired.get(peerId)?.timer === timer) {
-                        this._pendingPaymentRequired.delete(peerId);
-                    }
-                    resolve(payload);
-                },
-                reject: () => {
-                    clearTimeout(timer);
-                    if (this._pendingPaymentRequired.get(peerId)?.timer === timer) {
-                        this._pendingPaymentRequired.delete(peerId);
-                    }
-                    resolve(null);
-                },
-                timer,
-            });
-        });
-    }
-    /**
-     * Apply a pre-signed SpendingAuth from the x-antseed-spending-auth header.
-     * Sends it to the seller via PaymentMux and waits for AuthAck.
-     */
-    async _applyExternalSpendingAuth(peer, conn, headerValue) {
-        const pmux = this._getOrCreateBuyerPaymentMux(peer.peerId, conn);
-        let payload;
-        try {
-            const decoded = Buffer.from(headerValue, 'base64').toString('utf-8');
-            payload = JSON.parse(decoded);
-        }
-        catch {
-            throw new Error('Invalid x-antseed-spending-auth header: failed to decode');
-        }
-        debugLog(`[Node] External SpendingAuth: session=${payload.sessionId.slice(0, 18)}... amount=${payload.maxAmountUsdc}`);
-        // Store session so handleAuthAck can find it
-        if (this._sessionStore) {
-            const sellerEvmAddr = payload.sellerEvmAddr ?? '';
-            this._sessionStore.upsertSession({
-                sessionId: payload.sessionId,
-                peerId: peer.peerId,
-                role: 'buyer',
-                sellerEvmAddr,
-                buyerEvmAddr: payload.buyerEvmAddr,
-                nonce: payload.nonce,
-                authMax: payload.maxAmountUsdc,
-                deadline: payload.deadline,
-                previousSessionId: payload.previousSessionId,
-                previousConsumption: payload.previousConsumption,
-                tokensDelivered: '0',
-                requestCount: 0,
-                reservedAt: Date.now(),
-                settledAt: null,
-                settledAmount: null,
-                status: 'active',
-                createdAt: Date.now(),
-                updatedAt: Date.now(),
-            });
-        }
-        // Send the pre-signed SpendingAuth to the seller
-        pmux.sendSpendingAuth(payload);
-        debugLog(`[Node] External SpendingAuth sent to seller ${peer.peerId.slice(0, 12)}..., waiting for AuthAck...`);
-        await this._waitForLockConfirmation(peer.peerId);
-        debugLog(`[Node] AuthAck received from seller ${peer.peerId.slice(0, 12)}...`);
-        this._buyerLockedPeers.add(peer.peerId);
-        this.emit('payment:signed', {
-            peerId: peer.peerId,
-            sellerEvmAddr: payload.sellerEvmAddr ?? '',
-            amount: payload.maxAmountUsdc,
-        });
-    }
-    async _negotiatePayment(peer, conn) {
-        // Per-peer mutex: if another request is already negotiating, wait for it
-        const existing = this._paymentNegotiationLocks.get(peer.peerId);
-        if (existing) {
-            await existing;
-            return;
-        }
-        const negotiation = this._doNegotiatePayment(peer, conn);
-        this._paymentNegotiationLocks.set(peer.peerId, negotiation);
-        try {
-            await negotiation;
-        }
-        finally {
-            this._paymentNegotiationLocks.delete(peer.peerId);
-        }
-    }
-    async _doNegotiatePayment(peer, conn) {
-        const bpm = this._buyerPaymentManager;
-        if (!bpm) {
-            throw new Error('Payment negotiation unavailable — no escrow contract configured');
-        }
-        // If already locked from a previous successful negotiation, skip
-        if (this._buyerLockedPeers.has(peer.peerId))
-            return;
-        const pmux = this._getOrCreateBuyerPaymentMux(peer.peerId, conn);
-        // Check if PaymentRequired was already buffered (arrives in same I/O tick as 402)
-        const buffered = this._bufferedPaymentRequired.get(peer.peerId);
-        if (buffered) {
-            this._bufferedPaymentRequired.delete(peer.peerId);
-            debugLog(`[Node] Using buffered PaymentRequired from ${peer.peerId.slice(0, 12)}...`);
-        }
-        const PAYMENT_REQUIRED_TIMEOUT_MS = 10_000;
-        const requirements = buffered ?? await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this._pendingPaymentRequired.delete(peer.peerId);
-                reject(new Error(`PaymentRequired timeout from seller ${peer.peerId.slice(0, 12)}...`));
-            }, PAYMENT_REQUIRED_TIMEOUT_MS);
-            this._pendingPaymentRequired.set(peer.peerId, { resolve, reject, timer });
-        });
-        debugLog(`[Node] PaymentRequired from ${peer.peerId.slice(0, 12)}...: rate=${requirements.tokenRate} cap=${requirements.firstSignCap} suggested=${requirements.suggestedAmount}`);
-        // Fetch on-chain context so the UI can show the buyer real data
-        let approvalContext = null;
-        if (this._escrowClient && this._identity) {
-            try {
-                const buyerAddr = identityToEvmAddress(this._identity);
-                approvalContext = await this._escrowClient.getBuyerApprovalContext(buyerAddr, requirements.sellerEvmAddr);
-                debugLog(`[Node] Approval context: balance=${approvalContext.buyerBalance.available} isFirstSign=${approvalContext.isFirstSign} cooldown=${approvalContext.cooldownRemainingSecs}s`);
-            }
-            catch (err) {
-                debugWarn(`[Node] Failed to fetch approval context: ${err instanceof Error ? err.message : err}`);
-            }
-        }
-        // Cap amount before building approval info so the displayed amount
-        // matches what will actually be signed via authorizeSpending.
-        let amount;
-        try {
-            amount = BigInt(requirements.suggestedAmount);
-        }
-        catch {
-            throw new Error(`Invalid suggestedAmount from seller ${peer.peerId.slice(0, 12)}...: "${requirements.suggestedAmount}"`);
-        }
-        if (approvalContext) {
-            const available = approvalContext.buyerBalance.available;
-            if (amount > available)
-                amount = available;
-            if (approvalContext.isFirstSign) {
-                const cap = approvalContext.firstSignCap;
-                if (amount > cap)
-                    amount = cap;
-            }
-        }
-        if (amount <= 0n) {
-            throw new Error(`Insufficient escrow balance to authorize payment to ${peer.peerId.slice(0, 12)}...`);
-        }
-        const approvalInfo = {
-            peerId: peer.peerId,
-            sellerEvmAddr: requirements.sellerEvmAddr,
-            tokenRate: requirements.tokenRate,
-            firstSignCap: requirements.firstSignCap,
-            suggestedAmount: amount.toString(),
-            buyerAvailableUsdc: approvalContext ? approvalContext.buyerBalance.available.toString() : null,
-            isFirstSign: approvalContext?.isFirstSign ?? null,
-            cooldownRemainingSecs: approvalContext?.cooldownRemainingSecs ?? null,
-        };
-        this.emit('payment:required', approvalInfo);
-        try {
-            await bpm.authorizeSpending(peer.peerId, requirements.sellerEvmAddr, pmux, amount);
-            debugLog(`[Node] SpendingAuth sent to seller ${peer.peerId.slice(0, 12)}..., waiting for AuthAck...`);
-            await this._waitForLockConfirmation(peer.peerId);
-            debugLog(`[Node] AuthAck received from seller ${peer.peerId.slice(0, 12)}...`);
-            this._buyerLockedPeers.add(peer.peerId);
-            // Notify listeners what was signed
-            this.emit('payment:signed', {
-                peerId: peer.peerId,
-                sellerEvmAddr: requirements.sellerEvmAddr,
-                amount: amount.toString(),
-                tokenRate: requirements.tokenRate,
-            });
-        }
-        catch (err) {
-            debugWarn(`[Node] Payment negotiation failed for ${peer.peerId.slice(0, 12)}...: ${err instanceof Error ? err.message : err}`);
-            throw err;
-        }
-    }
-    /**
-     * 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)`);
-    }
-    /**
-     * Clean up buyer payment sessions on shutdown.
-     * Sessions are persisted in SessionStore and will be resumed on next connect.
-     */
-    async _endAllBuyerSessions() {
-        const bpm = this._buyerPaymentManager;
-        if (!bpm)
-            return;
-        // Sessions persist in SQLite; no explicit end needed.
-        // The buyer will reference them as previousSession on next connect.
-        debugLog(`[Node] Buyer sessions persisted for next reconnection`);
-    }
     _resolvePublicAddress(result) {
         const metadataPublicAddress = result.metadata.publicAddress?.trim();
         if (metadataPublicAddress && parsePublicAddress(metadataPublicAddress) !== null) {
@@ -1892,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