mppx 0.12.0 → 0.13.2

package/dist/tempo/legacy/client/Session.js

@@ -1,279 +0,0 @@
-import { parseUnits } from 'viem';
-import { tempo as tempo_chain } from 'viem/tempo/chains';
-import * as Constants from '../../../Constants.js';
-import * as Method from '../../../Method.js';
-import * as Account from '../../../viem/Account.js';
-import * as Client from '../../../viem/Client.js';
-import * as z from '../../../zod.js';
-import { getAccountSignerAddress } from '../../internal/account.js';
-import * as defaults from '../../internal/defaults.js';
-import * as Methods from '../../Methods.js';
-import { signVoucher } from '../session/Voucher.js';
-import { createOpenPayload, createVoucherPayload, resolveEscrow, serializeCredential, tryRecoverChannel, } from './ChannelOps.js';
-/** Runtime schema for legacy low-level session credential context. */
-export const sessionContextSchema = z.object({
-    account: z.optional(z.custom()),
-    action: z.optional(z.enum(['open', 'topUp', 'voucher', 'close'])),
-    channelId: z.optional(z.string()),
-    cumulativeAmount: z.optional(z.amount()),
-    cumulativeAmountRaw: z.optional(z.string()),
-    transaction: z.optional(z.string()),
-    additionalDeposit: z.optional(z.amount()),
-    additionalDepositRaw: z.optional(z.string()),
-    depositRaw: z.optional(z.string()),
-});
-/**
- * Creates a session payment method for use with `Mppx.create()`.
- *
- * Supports both auto mode (set `deposit` to manage channels automatically)
- * and manual mode (pass `context.action` to control each step).
- *
- * @example
- * ```ts
- * // Auto mode
- * import { Mppx, tempo } from 'mppx/client'
- *
- * const mppx = Mppx.create({
- *   methods: [tempo({
- *     account: privateKeyToAccount('0x...'),
- *     deposit: '10',
- *   })],
- * })
- *
- * const res = await mppx.fetch('/api/chat?prompt=hello')
- * ```
- *
- * @example
- * ```ts
- * // Manual mode
- * const mppx = Mppx.create({
- *   methods: [tempo({ account })],
- * })
- *
- * const credential = await mppx.createCredential(response, {
- *   action: 'voucher',
- *   channelId: '0x...',
- *   cumulativeAmount: '1',
- * })
- * ```
- */
-export function session(parameters = {}) {
-    const { allowCustomEscrow = false, decimals = defaults.decimals } = parameters;
-    const getClient = Client.getResolver({
-        chain: tempo_chain,
-        getClient: parameters.getClient,
-        rpcUrl: defaults.rpcUrl,
-    });
-    const getAccount = Account.getResolver({ account: parameters.account });
-    const maxDeposit = parameters.maxDeposit !== undefined ? parseUnits(parameters.maxDeposit, decimals) : undefined;
-    const escrowContractMap = new Map();
-    const channels = new Map();
-    const channelIdToKey = new Map();
-    function notifyUpdate(entry) {
-        parameters.onChannelUpdate?.(entry);
-    }
-    function channelKey(payee, currency, escrow) {
-        return `${payee.toLowerCase()}:${currency.toLowerCase()}:${escrow.toLowerCase()}`;
-    }
-    function resolveEscrowCached(challenge, chainId, channelId) {
-        if (channelId) {
-            const cached = escrowContractMap.get(channelId);
-            if (cached)
-                return resolveEscrow(challenge, chainId, cached);
-        }
-        return resolveEscrow(challenge, chainId, parameters.escrowContract, allowCustomEscrow);
-    }
-    async function autoManageCredential(challenge, account, context) {
-        const md = challenge.request.methodDetails;
-        const chainId = md?.chainId ?? 0;
-        const client = await getClient({ chainId });
-        const escrowContract = resolveEscrowCached(challenge, chainId);
-        const payee = challenge.request.recipient;
-        const currency = challenge.request.currency;
-        const amount = BigInt(challenge.request.amount);
-        const suggestedDepositRaw = challenge.request
-            .suggestedDeposit;
-        const suggestedDeposit = suggestedDepositRaw ? BigInt(suggestedDepositRaw) : undefined;
-        const deposit = (() => {
-            if (context?.depositRaw)
-                return BigInt(context.depositRaw);
-            if (parameters.deposit !== undefined)
-                return parseUnits(parameters.deposit, decimals);
-            if (suggestedDeposit !== undefined && maxDeposit !== undefined)
-                return suggestedDeposit < maxDeposit ? suggestedDeposit : maxDeposit;
-            if (maxDeposit !== undefined)
-                return maxDeposit;
-            if (suggestedDeposit !== undefined)
-                return suggestedDeposit;
-            throw new Error('No deposit amount available. Set `deposit`, `maxDeposit`, or ensure the server challenge includes `suggestedDeposit`.');
-        })();
-        const voucherSigner = parameters.voucherSigner ?? account;
-        const key = channelKey(payee, currency, escrowContract);
-        let entry = channels.get(key);
-        if (!entry) {
-            const suggestedChannelId = (context?.channelId ?? md?.channelId);
-            if (suggestedChannelId) {
-                const recovered = await tryRecoverChannel(client, escrowContract, suggestedChannelId, chainId);
-                if (recovered) {
-                    const contextCumulative = context?.cumulativeAmountRaw
-                        ? BigInt(context.cumulativeAmountRaw)
-                        : context?.cumulativeAmount
-                            ? parseUnits(context.cumulativeAmount, decimals)
-                            : undefined;
-                    if (contextCumulative !== undefined)
-                        recovered.cumulativeAmount = contextCumulative;
-                    channels.set(key, recovered);
-                    channelIdToKey.set(recovered.channelId, key);
-                    escrowContractMap.set(recovered.channelId, escrowContract);
-                    entry = recovered;
-                    notifyUpdate(entry);
-                }
-                else if (context?.channelId) {
-                    throw new Error(`Channel ${context.channelId} cannot be reused (closed or not found on-chain).`);
-                }
-            }
-        }
-        // A channel only admits vouchers from the authorizedSigner it was opened
-        // with, so a cached or recovered entry stops being reusable once the
-        // resolved signer changes. Fall through to open a fresh channel instead
-        // of emitting a voucher the escrow would reject.
-        if (entry?.opened &&
-            entry.authorizedSigner.toLowerCase() !== getAccountSignerAddress(voucherSigner).toLowerCase())
-            entry = undefined;
-        let payload;
-        if (entry?.opened) {
-            entry.cumulativeAmount += amount;
-            payload = await createVoucherPayload(client, account, entry.channelId, entry.cumulativeAmount, escrowContract, chainId, voucherSigner);
-            notifyUpdate(entry);
-        }
-        else {
-            const result = await createOpenPayload(client, account, {
-                voucherSigner,
-                escrowContract,
-                payee,
-                currency,
-                deposit,
-                initialAmount: amount,
-                chainId,
-                feePayer: md?.feePayer,
-            });
-            channels.set(key, result.entry);
-            channelIdToKey.set(result.entry.channelId, key);
-            escrowContractMap.set(result.entry.channelId, escrowContract);
-            payload = result.payload;
-            notifyUpdate(result.entry);
-        }
-        return serializeCredential(challenge, payload, chainId, account);
-    }
-    async function manualCredential(challenge, account, context) {
-        const md = challenge.request.methodDetails;
-        const chainId = md?.chainId ?? 0;
-        const client = await getClient({ chainId });
-        const action = context.action;
-        const { channelId: channelIdRaw, transaction } = context;
-        const voucherSigner = parameters.voucherSigner ?? account;
-        const channelId = channelIdRaw;
-        const cumulativeAmount = context.cumulativeAmountRaw
-            ? BigInt(context.cumulativeAmountRaw)
-            : context.cumulativeAmount
-                ? parseUnits(context.cumulativeAmount, decimals)
-                : undefined;
-        const resolvedAdditionalDeposit = context.additionalDepositRaw
-            ? BigInt(context.additionalDepositRaw)
-            : context.additionalDeposit
-                ? parseUnits(context.additionalDeposit, decimals)
-                : undefined;
-        const escrowContract = resolveEscrowCached(challenge, chainId, channelId);
-        escrowContractMap.set(channelId, escrowContract);
-        let payload;
-        switch (action) {
-            case 'open': {
-                if (!transaction)
-                    throw new Error('transaction required for open action');
-                if (cumulativeAmount === undefined)
-                    throw new Error('cumulativeAmount required for open action');
-                const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, chainId, voucherSigner);
-                payload = {
-                    action: 'open',
-                    type: 'transaction',
-                    channelId,
-                    transaction: transaction,
-                    authorizedSigner: getAccountSignerAddress(voucherSigner),
-                    cumulativeAmount: cumulativeAmount.toString(),
-                    signature,
-                };
-                break;
-            }
-            case 'topUp':
-                if (!transaction)
-                    throw new Error('transaction required for topUp action');
-                if (resolvedAdditionalDeposit === undefined)
-                    throw new Error('additionalDeposit required for topUp action');
-                payload = {
-                    action: 'topUp',
-                    type: 'transaction',
-                    channelId,
-                    transaction: transaction,
-                    additionalDeposit: resolvedAdditionalDeposit.toString(),
-                };
-                break;
-            case 'voucher': {
-                if (cumulativeAmount === undefined)
-                    throw new Error('cumulativeAmount required for voucher action');
-                payload = await createVoucherPayload(client, account, channelId, cumulativeAmount, escrowContract, chainId, voucherSigner);
-                const key = channelIdToKey.get(channelId);
-                if (key) {
-                    const entry = channels.get(key);
-                    if (entry) {
-                        entry.cumulativeAmount =
-                            entry.cumulativeAmount > cumulativeAmount ? entry.cumulativeAmount : cumulativeAmount;
-                        notifyUpdate(entry);
-                    }
-                }
-                break;
-            }
-            case 'close': {
-                if (cumulativeAmount === undefined)
-                    throw new Error('cumulativeAmount required for close action');
-                const signature = await signVoucher(client, account, { channelId, cumulativeAmount }, escrowContract, chainId, voucherSigner);
-                payload = {
-                    action: 'close',
-                    channelId,
-                    cumulativeAmount: cumulativeAmount.toString(),
-                    signature,
-                };
-                const closeKey = channelIdToKey.get(channelId);
-                if (closeKey) {
-                    const entry = channels.get(closeKey);
-                    if (entry) {
-                        entry.opened = false;
-                        entry.cumulativeAmount =
-                            entry.cumulativeAmount > cumulativeAmount ? entry.cumulativeAmount : cumulativeAmount;
-                        notifyUpdate(entry);
-                    }
-                }
-                break;
-            }
-        }
-        return serializeCredential(challenge, payload, chainId, account);
-    }
-    return Method.toClient(Methods.session, {
-        canHandleChallenge({ challenge }) {
-            const sessionProtocolMarker = Constants.getMethodDetail(challenge.request.methodDetails, Constants.MethodDetailKeys.sessionProtocol);
-            return (sessionProtocolMarker === undefined ||
-                sessionProtocolMarker === Constants.SessionProtocols.v1);
-        },
-        context: sessionContextSchema,
-        async createCredential({ challenge, context }) {
-            const chainId = challenge.request.methodDetails?.chainId ?? 0;
-            const client = await getClient({ chainId });
-            const account = getAccount(client, context);
-            if (!context?.action && (parameters.deposit !== undefined || maxDeposit !== undefined))
-                return autoManageCredential(challenge, account, context);
-            if (context?.action)
-                return manualCredential(challenge, account, context);
-            throw new Error('No `action` in context and no `deposit` or `maxDeposit` configured. Either provide context with action/channelId/cumulativeAmount, or configure `deposit`/`maxDeposit` for auto-management.');
-        },
-    });
-}
-//# sourceMappingURL=Session.js.map

package/dist/tempo/legacy/client/SessionManager.d.ts

@@ -1,100 +0,0 @@
-import type { Hex } from 'ox';
-import { type Account as viem_Account, type Address } from 'viem';
-import * as Challenge from '../../../Challenge.js';
-import * as AcceptPayment from '../../../internal/AcceptPayment.js';
-import type * as Account from '../../../viem/Account.js';
-import type * as Client from '../../../viem/Client.js';
-import type { SessionReceipt } from '../../session/precompile/Protocol.js';
-import { session as sessionPlugin } from './Session.js';
-type WebSocketConstructor = {
-    new (url: string | URL, protocols?: string | string[]): WebSocket;
-};
-type SessionMethod = ReturnType<typeof sessionPlugin>;
-type SessionOrderChallenges = AcceptPayment.OrderChallenges<readonly [SessionMethod]>;
-type SessionRequestInit = RequestInit & {
-    orderChallenges?: SessionOrderChallenges | undefined;
-};
-/** Auto-driving legacy client manager for HTTP, SSE, and WebSocket sessions. */
-export type SessionManager = {
-    /** Active legacy channel ID, when opened or recovered. */
-    readonly channelId: Hex.Hex | undefined;
-    /** Local cumulative voucher authorization in raw token units. */
-    readonly cumulative: bigint;
-    /** Whether the manager currently has an open local channel. */
-    readonly opened: boolean;
-    /** Opens a legacy contract-backed channel before the first paid request. */
-    open(options?: {
-        deposit?: bigint;
-    }): Promise<void>;
-    /** Performs the HTTP 402 challenge/retry flow and returns receipt metadata. */
-    fetch(input: RequestInfo | URL, init?: SessionRequestInit): Promise<PaymentResponse>;
-    /** Opens a paid SSE stream and responds to voucher requests. */
-    sse(input: RequestInfo | URL, init?: SessionRequestInit & {
-        onReceipt?: ((receipt: SessionReceipt) => void) | undefined;
-        signal?: AbortSignal | undefined;
-    }): Promise<AsyncIterable<string>>;
-    /** Opens a paid WebSocket session and manages in-band payment frames. */
-    ws(input: string | URL, init?: {
-        onReceipt?: ((receipt: SessionReceipt) => void) | undefined;
-        orderChallenges?: SessionOrderChallenges | undefined;
-        protocols?: string | string[] | undefined;
-        signal?: AbortSignal | undefined;
-    }): Promise<WebSocket>;
-    /** Cooperatively closes the active legacy channel. */
-    close(): Promise<SessionReceipt | undefined>;
-};
-/** HTTP response enriched with latest legacy session metadata. */
-export type PaymentResponse = Response & {
-    /** Parsed payment receipt, when the response included one. */
-    receipt: SessionReceipt | null;
-    /** Last session challenge observed by the manager. */
-    challenge: Challenge.Challenge | null;
-    /** Active channel ID, when available. */
-    channelId: Hex.Hex | null;
-    /** Local cumulative voucher authorization in raw token units. */
-    cumulative: bigint;
-};
-/**
- * Creates a session manager that handles the full client payment lifecycle:
- * channel open, incremental vouchers, SSE streaming, and channel close.
- *
- * Internally delegates to the `session()` method for all
- * channel state management and credential creation, and to `Fetch.from`
- * for the 402 challenge/retry flow.
- *
- * ## Session resumption
- *
- * All channel state is held **in memory**. If the client process restarts,
- * the session is lost and a new on-chain channel will be opened on the next
- * request — the previous channel's deposit is orphaned until manually closed.
- *
- * When the server includes a `channelId` in the 402 challenge `methodDetails`,
- * the client will attempt to recover the channel by reading its on-chain state
- * via `getOnChainChannel()`. If the channel has a positive deposit and is not
- * finalized, it resumes from the on-chain settled amount.
- */
-export declare function sessionManager(parameters: sessionManager.Parameters): SessionManager;
-/** Type helpers for the legacy auto-driving session manager. */
-export declare namespace sessionManager {
-    type Parameters = Account.getResolver.Parameters & Client.getResolver.Parameters & {
-        /** Accept a noncanonical escrow contract advertised by the server. @default false */
-        allowCustomEscrow?: boolean | undefined;
-        /** Account that signs voucher digests. Defaults to `account`; access-key accounts sign raw vouchers as their access-key address. */
-        voucherSigner?: viem_Account | undefined;
-        /** Viem client instance. Shorthand for `getClient: () => client`. */
-        client?: import('viem').Client | undefined;
-        /** Token decimals used to convert `maxDeposit` to raw units. Defaults to `6`. */
-        decimals?: number | undefined;
-        /** Exact escrow contract address pin. Takes precedence over `allowCustomEscrow`. */
-        escrowContract?: Address | undefined;
-        fetch?: typeof globalThis.fetch | undefined;
-        /** Maximum deposit in human-readable units (e.g. `'10'` for 10 tokens). Converted to raw units via `decimals`. */
-        maxDeposit?: string | undefined;
-        /** Filters and sorts supported session challenges before credential creation. */
-        orderChallenges?: SessionOrderChallenges | undefined;
-        /** Optional websocket constructor for runtimes without a global WebSocket. */
-        webSocket?: WebSocketConstructor | undefined;
-    };
-}
-export {};
-//# sourceMappingURL=SessionManager.d.ts.map