@antseed/web-sdk 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,174 @@
+/**
+ * High-level browser buyer built on the SHARED buyer machinery from
+ * @antseed/buyer-core — the same BuyerRequestHandler / BuyerPaymentManager /
+ * BuyerPaymentNegotiator stack the node buyer proxy runs, wired to a WebRTC
+ * transport and an injectable channel store. `create()` supplies durable
+ * browser persistence; the public constructor retains the in-memory default.
+ */
+import { type AbstractSigner } from 'ethers';
+import { BuyerPaymentNegotiator, ChannelsClient, DepositsClient, ProxyMux, VerificationMux, type BuyerChannelStore, type BuyerPeerView, type BuyerSigner, type StoredChannel } from '@antseed/buyer-core';
+import { type CloseChannelResultPayload, type PeerMetadata, type PeerId, type SerializedHttpRequest, type SerializedHttpResponse } from '@antseed/protocol';
+import { SellerConnection, type ConnectionOptions, type RtcEnvironment } from './connection.js';
+import { BuyerTabLock, type WebLockManagerLike } from './tab-lock.js';
+export interface SellerSummary extends BuyerPeerView {
+    displayName?: string;
+    publicAddress?: string;
+    sellerContract?: string;
+    metadata?: PeerMetadata;
+}
+export interface WebPaymentConfig {
+    chainId: number;
+    channelsContractAddress: string;
+    depositsContractAddress: string;
+    usdcAddress: string;
+    /** RPC endpoint for read-only deposit/channel checks. Empty disables them. */
+    rpcUrl: string;
+    fallbackRpcUrls?: string[];
+    maxPerRequestUsdc?: bigint;
+    maxReserveAmountUsdc?: bigint;
+    defaultAuthDurationSecs?: number;
+    costToleranceMultiplier?: number;
+}
+export interface ClientOptions {
+    /** Relay base URL, e.g. https://relay.antseed.com */
+    relayUrl: string;
+    /**
+     * Buyer hot-wallet key, or any ethers AbstractSigner exposing its address
+     * as a property (Wallet, JsonRpcSigner, custom non-extractable-key
+     * signers). The peerId is its EVM address. Note: the payment stack signs a
+     * SpendingAuth per request, so signers that prompt per signature (browser
+     * extension wallets) are impractical for chat-style traffic.
+     */
+    privateKey?: string;
+    wallet?: BuyerSigner;
+    /** Defaults to Base mainnet (chain 8453). */
+    payment?: Partial<WebPaymentConfig>;
+    connection?: ConnectionOptions;
+    requestTimeoutMs?: number;
+    /** Receives asynchronous transport/protocol failures before the session closes. */
+    onError?: (error: Error, context: {
+        sellerPeerId: PeerId;
+    }) => void;
+    /** Receives background IndexedDB failures as soon as a queued write fails. */
+    onPersistenceError?: (error: Error) => void;
+    /** Reject non-empty DHT snapshots older than this. Defaults to 15 minutes. */
+    maxSellerSnapshotAgeMs?: number;
+    /** Override RTCPeerConnection/WebSocket (browser globals by default). */
+    env?: Partial<RtcEnvironment>;
+    /**
+     * Pre-opened custom channel store. The public constructor defaults to a
+     * fresh in-memory store; production browser apps should prefer `create()`
+     * so signed authorizations are durably committed before transmission and
+     * signing is serialized across tabs.
+     */
+    channelStore?: BuyerChannelStore;
+    /** Durable browser storage and cross-tab coordination options. */
+    persistence?: {
+        databaseName?: string;
+        indexedDB?: IDBFactory;
+        locks?: WebLockManagerLike;
+        /** Wait for the other tab to release the buyer instead of failing fast. */
+        waitForLock?: boolean;
+    };
+    /** Override the on-chain read clients (tests, custom RPC stacks). */
+    depositsClient?: DepositsClient | null;
+    channelsClient?: ChannelsClient | null;
+}
+export interface RequestInput {
+    method?: string;
+    path: string;
+    headers?: Record<string, string>;
+    body?: Uint8Array | string;
+    /** Selects the provider on the seller (x-antseed-provider). */
+    provider?: string;
+}
+export interface StreamCallbacks {
+    onChunk?: (data: Uint8Array, done: boolean) => void;
+}
+interface SessionWiring {
+    conn: SellerConnection;
+    proxyMux: ProxyMux;
+    verificationMux: VerificationMux;
+}
+export declare class AntseedWebClient {
+    private readonly options;
+    private readonly tabLock?;
+    private readonly identity;
+    private readonly env;
+    private readonly payment;
+    private readonly store;
+    private readonly channelsClient;
+    private readonly handler;
+    readonly negotiator: BuyerPaymentNegotiator;
+    private readonly sessions;
+    private readonly sessionPromises;
+    private closed;
+    constructor(options: ClientOptions, tabLock?: BuyerTabLock | undefined);
+    /**
+     * Open a production browser client. This acquires the identity-wide tab lock
+     * and hydrates IndexedDB before BuyerPaymentManager is constructed.
+     */
+    static create(options: ClientOptions): Promise<AntseedWebClient>;
+    /**
+     * In-memory client for tests and free interoperability experiments. Paid
+     * applications must use `create()` so reload recovery and tab exclusion are
+     * active.
+     */
+    static ephemeral(options: ClientOptions): AntseedWebClient;
+    get peerId(): PeerId;
+    sellers(): Promise<SellerSummary[]>;
+    /** Connect to a seller. `peer` extras (pricing, metadata) improve cost validation. */
+    connect(seller: string | SellerSummary, peer?: Partial<BuyerPeerView>): Promise<SellerSession>;
+    /** @internal */
+    requireSession(peerId: PeerId): Promise<SessionWiring>;
+    private openSession;
+    /** @internal */
+    sendRequest(peer: BuyerPeerView, req: SerializedHttpRequest, callbacks?: {
+        onChunk?: (data: Uint8Array, done: boolean) => void;
+    }): Promise<SerializedHttpResponse>;
+    disconnect(sellerPeerId: string): void;
+    closeAll(): void;
+    listActiveChannels(): StoredChannel[];
+    /** @internal */
+    getActiveChannelForPeer(sellerPeerId: string): StoredChannel | null;
+    /** Start the contract grace period using the buyer's configured operator signer. */
+    requestOnChainClose(channelId: string, operatorSigner: AbstractSigner): Promise<string>;
+    /** Release the remaining reserve after the contract grace period has elapsed. */
+    withdrawTimedOutChannel(channelId: string, operatorSigner: AbstractSigner): Promise<string>;
+    /** Close all transports, flush storage, and release this buyer for another tab. */
+    close(): Promise<void>;
+    /** @internal */
+    requestChannelClose(peer: BuyerPeerView, options?: {
+        includeAuth?: boolean;
+        timeoutMs?: number;
+    }): Promise<CloseChannelResultPayload>;
+    private dropSession;
+    private failSession;
+    private assertOpen;
+    private assertOwnedActiveChannel;
+}
+export declare function sellerSummaryFromMetadata(metadata: PeerMetadata): SellerSummary;
+export declare class SellerSession {
+    private readonly client;
+    readonly peer: BuyerPeerView;
+    constructor(client: AntseedWebClient, peer: BuyerPeerView);
+    /**
+     * Send one request through the shared buyer stack: 402 negotiation,
+     * NeedAuth signing, retries, and streaming all behave exactly like the
+     * node buyer proxy.
+     */
+    request(input: RequestInput, callbacks?: StreamCallbacks): Promise<SerializedHttpResponse>;
+    close(): void;
+    /** Ask the seller to settle and release this payment channel. */
+    closeChannel(options?: {
+        includeAuth?: boolean;
+        timeoutMs?: number;
+    }): Promise<CloseChannelResultPayload>;
+    /** Start the on-chain timeout path when cooperative close is unavailable. */
+    requestOnChainClose(operatorSigner: AbstractSigner): Promise<string>;
+    /** Withdraw after the on-chain close grace period. */
+    withdrawTimedOutChannel(operatorSigner: AbstractSigner): Promise<string>;
+    private requireActiveChannel;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AACvD,OAAO,EAEL,sBAAsB,EAItB,cAAc,EACd,cAAc,EACd,QAAQ,EAER,eAAe,EAEf,KAAK,iBAAiB,EAEtB,KAAK,aAAa,EAClB,KAAK,WAAW,EAEhB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGhG,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEtE,MAAM,WAAW,aAAc,SAAQ,aAAa;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB,EAAE,MAAM,CAAC;IAChC,uBAAuB,EAAE,MAAM,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACpC,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mFAAmF;IACnF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IACpE,8EAA8E;IAC9E,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC5C,8EAA8E;IAC9E,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC,kEAAkE;IAClE,WAAW,CAAC,EAAE;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,SAAS,CAAC,EAAE,UAAU,CAAC;QACvB,KAAK,CAAC,EAAE,kBAAkB,CAAC;QAC3B,2EAA2E;QAC3E,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;IACF,qEAAqE;IACrE,cAAc,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,cAAc,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;CACxC;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;CACrD;AAeD,UAAU,aAAa;IACrB,IAAI,EAAE,gBAAgB,CAAC;IACvB,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,EAAE,eAAe,CAAC;CAClC;AAED,qBAAa,gBAAgB;IAazB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAb3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IACzC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAiB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAwB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,QAAQ,CAAC,UAAU,EAAE,sBAAsB,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6C;IAC7E,OAAO,CAAC,MAAM,CAAS;gBAGJ,OAAO,EAAE,aAAa,EACtB,OAAO,CAAC,EAAE,YAAY,YAAA;IA2GzC;;;OAGG;WACU,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgCtE;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,gBAAgB;IAI1D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEK,OAAO,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IA+BzC,sFAAsF;IAChF,OAAO,CACX,MAAM,EAAE,MAAM,GAAG,aAAa,EAC9B,IAAI,GAAE,OAAO,CAAC,aAAa,CAAM,GAChC,OAAO,CAAC,aAAa,CAAC;IAYzB,gBAAgB;IACV,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;YAwB9C,WAAW;IA2BzB,gBAAgB;IACV,WAAW,CACf,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,qBAAqB,EAC1B,SAAS,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;KAAE,GAClE,OAAO,CAAC,sBAAsB,CAAC;IAYlC,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAOtC,QAAQ,IAAI,IAAI;IAOhB,kBAAkB,IAAI,aAAa,EAAE;IAIrC,gBAAgB;IAChB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAQnE,oFAAoF;IAC9E,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAM7F,iFAAiF;IAC3E,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IASjG,mFAAmF;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B,gBAAgB;IACV,mBAAmB,CACvB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GACtD,OAAO,CAAC,yBAAyB,CAAC;IAOrC,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,wBAAwB;CAajC;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,YAAY,GAAG,aAAa,CAyD/E;AAaD,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,aAAa;gBADX,MAAM,EAAE,gBAAgB,EAChC,IAAI,EAAE,aAAa;IAG9B;;;;OAIG;IACG,OAAO,CAAC,KAAK,EAAE,YAAY,EAAE,SAAS,GAAE,eAAoB,GAAG,OAAO,CAAC,sBAAsB,CAAC;IAcpG,KAAK,IAAI,IAAI;IAIb,iEAAiE;IACjE,YAAY,CAAC,OAAO,CAAC,EAAE;QACrB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAItC,6EAA6E;IAC7E,mBAAmB,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpE,sDAAsD;IACtD,uBAAuB,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAIxE,OAAO,CAAC,oBAAoB;CAK7B"}

package/dist/client.js

@@ -0,0 +1,470 @@
+/**
+ * High-level browser buyer built on the SHARED buyer machinery from
+ * @antseed/buyer-core — the same BuyerRequestHandler / BuyerPaymentManager /
+ * BuyerPaymentNegotiator stack the node buyer proxy runs, wired to a WebRTC
+ * transport and an injectable channel store. `create()` supplies durable
+ * browser persistence; the public constructor retains the in-memory default.
+ */
+import { Contract } from 'ethers';
+import { BuyerPaymentManager, BuyerPaymentNegotiator, BuyerRequestHandler, CHANNEL_ROLE, CHANNEL_STATUS, ChannelsClient, DepositsClient, ProxyMux, SellerAddressResolver, VerificationMux, } from '@antseed/buyer-core';
+import { MessageType, toPeerId, } from '@antseed/protocol';
+import { SellerConnection } from './connection.js';
+import { IndexedDbChannelStore, MemoryChannelStore } from './channel-store.js';
+import { signerFromPrivateKey } from './identity.js';
+import { BuyerTabLock } from './tab-lock.js';
+// Base mainnet defaults (see packages/node/src/payments/chain-config.ts).
+const BASE_MAINNET = {
+    chainId: 8453,
+    channelsContractAddress: '0xBA66d3b4fbCf472F6F11D6F9F96aaCE96516F09d',
+    depositsContractAddress: '0x0F7a3a8f4Da01637d1202bb5443fcF7F88F99fD2',
+    usdcAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+    rpcUrl: 'https://base.publicnode.com',
+};
+// Stay under the ~256 KiB SCTP message ceiling browsers negotiate with
+// libdatachannel sellers; the shared mux default (512 KiB) assumes node peers.
+const BROWSER_UPLOAD_THRESHOLD_BYTES = 192 * 1024;
+export class AntseedWebClient {
+    options;
+    tabLock;
+    identity;
+    env;
+    payment;
+    store;
+    channelsClient;
+    handler;
+    negotiator;
+    sessions = new Map();
+    sessionPromises = new Map();
+    closed = false;
+    constructor(options, tabLock) {
+        this.options = options;
+        this.tabLock = tabLock;
+        const wallet = resolveWallet(options);
+        this.identity = { peerId: toPeerId(wallet.address.slice(2).toLowerCase()), wallet };
+        this.store = options.channelStore ?? new MemoryChannelStore();
+        const globalRtc = globalThis.RTCPeerConnection;
+        const globalWs = globalThis.WebSocket;
+        const RTCPeerConnectionImpl = options.env?.RTCPeerConnection ?? globalRtc;
+        const WebSocketImpl = options.env?.WebSocket ?? globalWs;
+        if (!RTCPeerConnectionImpl || !WebSocketImpl) {
+            throw new Error('RTCPeerConnection/WebSocket unavailable — pass them via options.env');
+        }
+        this.env = { RTCPeerConnection: RTCPeerConnectionImpl, WebSocket: WebSocketImpl };
+        this.payment = { ...BASE_MAINNET, ...options.payment };
+        let depositsClient = null;
+        if (options.depositsClient !== undefined) {
+            depositsClient = options.depositsClient;
+        }
+        else if (this.payment.rpcUrl) {
+            depositsClient = new DepositsClient({
+                rpcUrl: this.payment.rpcUrl,
+                ...(this.payment.fallbackRpcUrls ? { fallbackRpcUrls: this.payment.fallbackRpcUrls } : {}),
+                contractAddress: this.payment.depositsContractAddress,
+                usdcAddress: this.payment.usdcAddress,
+                evmChainId: this.payment.chainId,
+            });
+        }
+        let channelsClient = null;
+        if (options.channelsClient !== undefined) {
+            channelsClient = options.channelsClient;
+        }
+        else if (this.payment.rpcUrl) {
+            channelsClient = new ChannelsClient({
+                rpcUrl: this.payment.rpcUrl,
+                ...(this.payment.fallbackRpcUrls ? { fallbackRpcUrls: this.payment.fallbackRpcUrls } : {}),
+                contractAddress: this.payment.channelsContractAddress,
+                evmChainId: this.payment.chainId,
+            });
+        }
+        this.channelsClient = channelsClient;
+        const sellerAddressResolver = channelsClient
+            ? new SellerAddressResolver({
+                isOperator: async (sellerContract, peerAddress) => {
+                    const contract = new Contract(sellerContract, ['function isOperator(address) view returns (bool)'], channelsClient.provider);
+                    return contract.getFunction('isOperator')(peerAddress);
+                },
+            })
+            : undefined;
+        const bpm = new BuyerPaymentManager(this.identity, {
+            rpcUrl: this.payment.rpcUrl,
+            ...(this.payment.fallbackRpcUrls ? { fallbackRpcUrls: this.payment.fallbackRpcUrls } : {}),
+            depositsContractAddress: this.payment.depositsContractAddress,
+            channelsContractAddress: this.payment.channelsContractAddress,
+            usdcAddress: this.payment.usdcAddress,
+            identityRegistryAddress: '0x0000000000000000000000000000000000000000',
+            chainId: this.payment.chainId,
+            defaultAuthDurationSecs: this.payment.defaultAuthDurationSecs ?? 900,
+            maxPerRequestUsdc: this.payment.maxPerRequestUsdc ?? 500000n,
+            maxReserveAmountUsdc: this.payment.maxReserveAmountUsdc ?? 1000000n,
+            ...(this.payment.costToleranceMultiplier !== undefined
+                ? { costToleranceMultiplier: this.payment.costToleranceMultiplier }
+                : {}),
+            dataDir: '',
+        }, this.store, sellerAddressResolver);
+        this.negotiator = new BuyerPaymentNegotiator(this.identity, bpm, depositsClient, channelsClient, this.store, {}, { emit: () => true }, sellerAddressResolver);
+        this.handler = new BuyerRequestHandler({ ...(options.requestTimeoutMs !== undefined ? { requestTimeoutMs: options.requestTimeoutMs } : {}) }, {
+            localPeerId: this.identity.peerId,
+            negotiator: this.negotiator,
+            verificationStorage: null,
+            verificationSampler: null,
+            getConnection: (peer) => this.requireSession(peer.peerId).then((s) => s.conn),
+            getMux: (peerId) => this.sessions.get(peerId).proxyMux,
+            getVerificationMux: (peerId) => this.sessions.get(peerId).verificationMux,
+            registerPaymentMux: () => { },
+        });
+    }
+    /**
+     * Open a production browser client. This acquires the identity-wide tab lock
+     * and hydrates IndexedDB before BuyerPaymentManager is constructed.
+     */
+    static async create(options) {
+        const wallet = resolveWallet(options);
+        const payment = { ...BASE_MAINNET, ...options.payment };
+        const locks = options.persistence?.locks
+            ?? globalThis.navigator?.locks;
+        if (!locks) {
+            throw new Error('Web Locks API unavailable — paid browser operation is disabled');
+        }
+        const scope = [
+            payment.chainId,
+            payment.channelsContractAddress.toLowerCase(),
+            wallet.address.toLowerCase(),
+        ].join(':');
+        const tabLock = await BuyerTabLock.acquire(`antseed:buyer:${scope}`, locks, {
+            wait: options.persistence?.waitForLock ?? false,
+        });
+        try {
+            const store = options.channelStore ?? await IndexedDbChannelStore.open({
+                databaseName: options.persistence?.databaseName ?? `antseed-web-sdk:${scope}`,
+                ...(options.persistence?.indexedDB ? { indexedDB: options.persistence.indexedDB } : {}),
+                ...(options.onPersistenceError ? { onWriteError: options.onPersistenceError } : {}),
+            });
+            const { privateKey: _privateKey, ...safeOptions } = options;
+            return new AntseedWebClient({ ...safeOptions, wallet, channelStore: store }, tabLock);
+        }
+        catch (error) {
+            await tabLock.release();
+            throw error;
+        }
+    }
+    /**
+     * In-memory client for tests and free interoperability experiments. Paid
+     * applications must use `create()` so reload recovery and tab exclusion are
+     * active.
+     */
+    static ephemeral(options) {
+        return new AntseedWebClient({ ...options, channelStore: options.channelStore ?? new MemoryChannelStore() });
+    }
+    get peerId() {
+        return this.identity.peerId;
+    }
+    async sellers() {
+        const res = await fetch(`${this.options.relayUrl.replace(/\/$/, '')}/sellers`);
+        if (!res.ok)
+            throw new Error(`relay /sellers failed: ${res.status}`);
+        const body = (await res.json());
+        let useDiscoveredPeers = body.peers.length > 0;
+        if (useDiscoveredPeers) {
+            const updatedAt = Date.parse(body.updatedAt);
+            const maxAge = this.options.maxSellerSnapshotAgeMs ?? 15 * 60_000;
+            if (!Number.isFinite(updatedAt) || Date.now() - updatedAt > maxAge) {
+                if (body.static.length === 0)
+                    throw new Error('relay seller snapshot is stale');
+                useDiscoveredPeers = false;
+            }
+        }
+        const byId = new Map();
+        for (const entry of body.static) {
+            const peerId = toPeerId(entry.peerId.toLowerCase());
+            byId.set(peerId, { peerId, providers: [], publicAddress: `${entry.host}:${entry.port}` });
+        }
+        if (useDiscoveredPeers) {
+            for (const metadata of body.peers) {
+                const peer = sellerSummaryFromMetadata(metadata);
+                byId.set(peer.peerId, peer);
+            }
+        }
+        return [...byId.values()];
+    }
+    /** Connect to a seller. `peer` extras (pricing, metadata) improve cost validation. */
+    async connect(seller, peer = {}) {
+        this.assertOpen();
+        const sellerPeerId = typeof seller === 'string' ? seller : seller.peerId;
+        const peerId = toPeerId(sellerPeerId.toLowerCase());
+        const sellerView = typeof seller === 'string'
+            ? {}
+            : seller;
+        const peerView = { ...sellerView, ...peer, peerId };
+        await this.requireSession(peerId);
+        return new SellerSession(this, peerView);
+    }
+    /** @internal */
+    async requireSession(peerId) {
+        this.assertOpen();
+        const existing = this.sessions.get(peerId);
+        if (existing) {
+            if (existing.conn.isOpen)
+                return existing;
+            // Close a lingering (e.g. mid-connect) session before overwriting it.
+            existing.conn.close();
+            this.dropSession(peerId);
+        }
+        const pending = this.sessionPromises.get(peerId);
+        if (pending)
+            return pending;
+        const opening = this.openSession(peerId);
+        this.sessionPromises.set(peerId, opening);
+        try {
+            return await opening;
+        }
+        finally {
+            if (this.sessionPromises.get(peerId) === opening) {
+                this.sessionPromises.delete(peerId);
+            }
+        }
+    }
+    async openSession(peerId) {
+        const bridgeUrl = `${this.options.relayUrl.replace(/\/$/, '').replace(/^http/, 'ws')}/bridge/${peerId}`;
+        const conn = await SellerConnection.connect(bridgeUrl, this.identity.wallet, this.env, this.options.connection);
+        if (this.closed) {
+            conn.close();
+            throw new Error('AntseedWebClient is closed');
+        }
+        const proxyMux = new ProxyMux(conn, { uploadThresholdBytes: BROWSER_UPLOAD_THRESHOLD_BYTES });
+        const verificationMux = new VerificationMux(conn);
+        const paymentMux = this.negotiator.getOrCreatePaymentMux(peerId, conn);
+        conn.onFrame = (frame) => {
+            if (frame.type >= 0x50 && frame.type <= 0x5f) {
+                void paymentMux.handleFrame(frame).catch((error) => this.failSession(peerId, error));
+            }
+            else if (frame.type >= 0x80 && frame.type <= 0x8f) {
+                void verificationMux.handleFrame(frame).catch((error) => this.failSession(peerId, error));
+            }
+            else if (frame.type !== MessageType.Ping && frame.type !== MessageType.Pong) {
+                void proxyMux.handleFrame(frame).catch((error) => this.failSession(peerId, error));
+            }
+        };
+        conn.onClose = () => this.dropSession(peerId);
+        const wiring = { conn, proxyMux, verificationMux };
+        this.sessions.set(peerId, wiring);
+        return wiring;
+    }
+    /** @internal */
+    async sendRequest(peer, req, callbacks) {
+        const session = await this.requireSession(peer.peerId);
+        await this.negotiator.recoverPendingReserveBeforeRequest(peer, session.conn);
+        const streamCallbacks = callbacks?.onChunk
+            ? {
+                onResponseChunk: (chunk) => callbacks.onChunk(chunk.data, chunk.done),
+            }
+            : undefined;
+        return this.handler.sendRequest(peer, req, streamCallbacks);
+    }
+    disconnect(sellerPeerId) {
+        const peerId = toPeerId(sellerPeerId.toLowerCase());
+        const session = this.sessions.get(peerId);
+        session?.conn.close();
+        this.dropSession(peerId);
+    }
+    closeAll() {
+        for (const [peerId, session] of [...this.sessions]) {
+            session.conn.close();
+            this.dropSession(peerId);
+        }
+    }
+    listActiveChannels() {
+        return this.store.getActiveChannelsByBuyer(CHANNEL_ROLE.BUYER, this.identity.wallet.address);
+    }
+    /** @internal */
+    getActiveChannelForPeer(sellerPeerId) {
+        return this.store.getActiveChannelByPeerAndBuyer(toPeerId(sellerPeerId.toLowerCase()), CHANNEL_ROLE.BUYER, this.identity.wallet.address);
+    }
+    /** Start the contract grace period using the buyer's configured operator signer. */
+    async requestOnChainClose(channelId, operatorSigner) {
+        this.assertOwnedActiveChannel(channelId);
+        if (!this.channelsClient)
+            throw new Error('channels client unavailable');
+        return this.channelsClient.requestClose(operatorSigner, channelId);
+    }
+    /** Release the remaining reserve after the contract grace period has elapsed. */
+    async withdrawTimedOutChannel(channelId, operatorSigner) {
+        this.assertOwnedActiveChannel(channelId);
+        if (!this.channelsClient)
+            throw new Error('channels client unavailable');
+        const txHash = await this.channelsClient.withdraw(operatorSigner, channelId);
+        this.store.updateChannelStatus(channelId, CHANNEL_STATUS.TIMEOUT);
+        await this.store.flush?.();
+        return txHash;
+    }
+    /** Close all transports, flush storage, and release this buyer for another tab. */
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await this.negotiator.drainPendingNeedAuth();
+        this.closeAll();
+        this.negotiator.cleanup();
+        try {
+            await this.store.flush?.();
+            await this.store.close?.();
+        }
+        finally {
+            await this.tabLock?.release();
+        }
+    }
+    /** @internal */
+    async requestChannelClose(peer, options) {
+        const session = await this.requireSession(peer.peerId);
+        const result = await this.negotiator.requestChannelClose(peer.peerId, session.conn, options);
+        await this.store.flush?.();
+        return result;
+    }
+    dropSession(peerId) {
+        const session = this.sessions.get(peerId);
+        session?.verificationMux.close();
+        this.negotiator.onPeerDisconnect(peerId);
+        this.sessions.delete(peerId);
+    }
+    failSession(peerId, cause) {
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        try {
+            this.options.onError?.(error, { sellerPeerId: peerId });
+        }
+        catch {
+            // Error observers are diagnostic only and must not create a second
+            // unhandled rejection while the failed session is being torn down.
+        }
+        finally {
+            this.disconnect(peerId);
+        }
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('AntseedWebClient is closed');
+    }
+    assertOwnedActiveChannel(channelId) {
+        this.assertOpen();
+        const channel = this.store.getChannel(channelId);
+        if (!channel
+            || channel.status !== CHANNEL_STATUS.ACTIVE
+            || channel.role !== CHANNEL_ROLE.BUYER
+            || channel.buyerEvmAddr.toLowerCase() !== this.identity.wallet.address.toLowerCase()) {
+            throw new Error('active channel is not owned by this buyer');
+        }
+        return channel;
+    }
+}
+export function sellerSummaryFromMetadata(metadata) {
+    const providers = metadata.providers.map((provider) => provider.provider);
+    const firstProvider = metadata.providers[0];
+    const providerPricing = {};
+    const providerServiceCategories = {};
+    const providerServiceApiProtocols = {};
+    const providerServiceUnitBillingModels = {};
+    const providerServiceCapabilities = {};
+    for (const announcement of metadata.providers) {
+        const provider = announcement.provider;
+        const services = Object.fromEntries(announcement.services.map((service) => [
+            service,
+            announcement.servicePricing?.[service] ?? announcement.defaultPricing,
+        ]));
+        const pricing = providerPricing[provider];
+        if (pricing) {
+            pricing.services ??= {};
+            Object.assign(pricing.services, services);
+        }
+        else {
+            providerPricing[provider] = {
+                defaults: { ...announcement.defaultPricing },
+                ...(Object.keys(services).length > 0 ? { services } : {}),
+            };
+        }
+        mergeServiceMatrix(providerServiceCategories, provider, announcement.serviceCategories);
+        mergeServiceMatrix(providerServiceApiProtocols, provider, announcement.serviceApiProtocols);
+        mergeServiceMatrix(providerServiceUnitBillingModels, provider, announcement.serviceUnitBillingModels);
+        mergeServiceMatrix(providerServiceCapabilities, provider, announcement.serviceCapabilities);
+    }
+    return {
+        peerId: toPeerId(metadata.peerId.toLowerCase()),
+        ...(metadata.displayName ? { displayName: metadata.displayName } : {}),
+        ...(metadata.publicAddress ? { publicAddress: metadata.publicAddress } : {}),
+        ...(metadata.sellerContract ? { sellerContract: metadata.sellerContract } : {}),
+        metadata,
+        providers,
+        ...(metadata.capabilities?.length ? { capabilities: [...metadata.capabilities] } : {}),
+        ...(Object.keys(providerPricing).length ? { providerPricing } : {}),
+        ...(Object.keys(providerServiceCategories).length ? { providerServiceCategories } : {}),
+        ...(Object.keys(providerServiceApiProtocols).length ? { providerServiceApiProtocols } : {}),
+        ...(Object.keys(providerServiceUnitBillingModels).length
+            ? { providerServiceUnitBillingModels }
+            : {}),
+        ...(Object.keys(providerServiceCapabilities).length ? { providerServiceCapabilities } : {}),
+        defaultInputUsdPerMillion: firstProvider?.defaultPricing.inputUsdPerMillion,
+        defaultOutputUsdPerMillion: firstProvider?.defaultPricing.outputUsdPerMillion,
+        defaultCachedInputUsdPerMillion: firstProvider?.defaultPricing.cachedInputUsdPerMillion,
+    };
+}
+function mergeServiceMatrix(target, provider, services) {
+    if (!services || Object.keys(services).length === 0)
+        return;
+    const existing = target[provider];
+    if (existing)
+        Object.assign(existing.services, services);
+    else
+        target[provider] = { services: { ...services } };
+}
+export class SellerSession {
+    client;
+    peer;
+    constructor(client, peer) {
+        this.client = client;
+        this.peer = peer;
+    }
+    /**
+     * Send one request through the shared buyer stack: 402 negotiation,
+     * NeedAuth signing, retries, and streaming all behave exactly like the
+     * node buyer proxy.
+     */
+    async request(input, callbacks = {}) {
+        const req = {
+            requestId: crypto.randomUUID(),
+            method: input.method ?? 'POST',
+            path: input.path,
+            headers: {
+                ...(input.provider ? { 'x-antseed-provider': input.provider } : {}),
+                ...input.headers,
+            },
+            body: typeof input.body === 'string' ? new TextEncoder().encode(input.body) : input.body ?? new Uint8Array(0),
+        };
+        return this.client.sendRequest(this.peer, req, callbacks);
+    }
+    close() {
+        this.client.disconnect(this.peer.peerId);
+    }
+    /** Ask the seller to settle and release this payment channel. */
+    closeChannel(options) {
+        return this.client.requestChannelClose(this.peer, options);
+    }
+    /** Start the on-chain timeout path when cooperative close is unavailable. */
+    requestOnChainClose(operatorSigner) {
+        return this.client.requestOnChainClose(this.requireActiveChannel().sessionId, operatorSigner);
+    }
+    /** Withdraw after the on-chain close grace period. */
+    withdrawTimedOutChannel(operatorSigner) {
+        return this.client.withdrawTimedOutChannel(this.requireActiveChannel().sessionId, operatorSigner);
+    }
+    requireActiveChannel() {
+        const channel = this.client.getActiveChannelForPeer(this.peer.peerId);
+        if (!channel)
+            throw new Error(`No active payment channel with seller ${this.peer.peerId.slice(0, 12)}...`);
+        return channel;
+    }
+}
+function resolveWallet(options) {
+    const wallet = options.wallet
+        ?? (options.privateKey ? signerFromPrivateKey(options.privateKey) : null);
+    if (!wallet)
+        throw new Error('provide privateKey or wallet');
+    return wallet;
+}
+//# sourceMappingURL=client.js.map