mppx 0.8.15 → 0.8.18

package/dist/tempo/session/server/RequestState.d.ts

@@ -2,6 +2,7 @@ import { type Account as viem_Account, type Address, type Hex } from 'viem';
 import * as Constants from '../../../Constants.js';
 import type * as Credential from '../../../Credential.js';
 import type { Challenge } from '../../../index.js';
+import type { MaybePromise } from '../../../internal/types.js';
 import type * as z from '../../../zod.js';
 import * as Methods from '../../Methods.js';
 import { isSessionContentRequest, type RequestBodyProbe } from '../../server/internal/request-body.js';
@@ -14,10 +15,14 @@ import { type ParameterFeePayer, type ResolvedFeePayer } from './Settlement.js';
 export type ResolveSessionSnapshotParameters = {
     /** Raw request amount that must be covered by the next voucher. */
     amount: bigint;
+    /** Already-loaded channel for `channelId`, skipping the store read. */
+    channel?: ChannelStore.State | null | undefined;
     /** Channel ID from credential or challenge request, when available. */
     channelId: Hex | undefined;
     /** Payment fields the reusable channel must match before it is advertised. */
     expected?: SessionSnapshotPaymentFields | undefined;
+    /** Optional alternate-rail matcher when the stored descriptor differs from logical payment fields. */
+    matchPaymentFields?: MatchSessionSnapshotPaymentFields | undefined;
     /** Server channel store. */
     store: ChannelStore.ChannelStore;
 };
@@ -32,6 +37,15 @@ export type SessionSnapshotPaymentFields = {
     /** Payee address expected by the challenge. */
     recipient: Address;
 };
+/**
+ * Validates an alternate channel descriptor against the logical session payment
+ * fields. `options.action` names the credential the snapshot serves: close
+ * credentials accept retired routes, so their recovery snapshots match
+ * inactive routes too.
+ */
+export type MatchSessionSnapshotPaymentFields = (channel: ChannelStore.StoredPrecompileChannel, expected: SessionSnapshotPaymentFields, options?: {
+    action?: SessionCredentialPayload['action'] | undefined;
+} | undefined) => MaybePromise<boolean>;
 /** Request metadata available to `resolveChannelId` without exposing a mutable `Request`. */
 export type SessionChannelIdRequest = {
     /** Request headers, useful for cookies or auth/session headers. */
@@ -125,6 +139,10 @@ export type SessionMethodDetails = {
     escrowContract: Address;
     /** Whether this challenge allows fee-sponsored management transactions. */
     feePayer?: boolean | undefined;
+    /** Fee token clients must use for open/top-up transactions. */
+    feeToken?: Address | undefined;
+    /** Whether clients may fund this logical session through the first-party machine-token rail. */
+    machineTokenEnabled?: boolean | undefined;
     /** Minimum raw-unit increase required for voucher credentials. */
     minVoucherDelta?: string | undefined;
     /** Channel operator address the client should encode in new open transactions. */
@@ -147,6 +165,7 @@ export type ResolveSessionPaymentRequestParameters = {
     decimals: number;
     defaultFeePayer?: viem_Account | undefined;
     getClient: ResolveRequestChainIdParameters['getClient'];
+    matchSnapshotPaymentFields?: MatchSessionSnapshotPaymentFields | undefined;
     parameterChainId?: number | undefined;
     parameterEscrowContract?: Address | undefined;
     parameterFeePayer?: ParameterFeePayer;

package/dist/tempo/session/server/RequestState.js

@@ -3,9 +3,10 @@ import * as Constants from '../../../Constants.js';
 import { VerificationFailedError } from '../../../Errors.js';
 import * as Methods from '../../Methods.js';
 import { captureRequestBodyProbe, isSessionContentRequest, } from '../../server/internal/request-body.js';
-import { tip20ChannelEscrow } from '../precompile/Protocol.js';
+import { tip20ChannelEscrow, uint96, } from '../precompile/Protocol.js';
+import * as Voucher from '../precompile/Voucher.js';
 import * as ChannelStore from './ChannelStore.js';
-import { requireSessionCredentialAction } from './CredentialVerification.js';
+import { requireSessionCredentialAction, requireSessionCredentialPayload, } from './CredentialVerification.js';
 import { resolveCredentialFeePayer, resolveRequestFeePayer, } from './Settlement.js';
 /** Normalizes a session channel ID hint when one is present. */
 export function normalizeSessionChannelId(value) {
@@ -29,6 +30,27 @@ function normalizeResolvedSessionChannelId(value) {
         return undefined;
     return ChannelStore.normalizeChannelId(value);
 }
+/** Returns a close credential's channel once its voucher signature verifies. */
+async function verifiedCloseCredentialChannel(credential, store) {
+    try {
+        const payload = requireSessionCredentialPayload(credential?.payload);
+        if (payload.action !== 'close')
+            return undefined;
+        const channelId = payload.channelId;
+        const channel = await store.getChannel(channelId);
+        if (!channel || !ChannelStore.isPrecompileState(channel))
+            return undefined;
+        const verified = Voucher.verifyVoucher(channel.escrowContract, channel.chainId, {
+            channelId,
+            cumulativeAmount: uint96(BigInt(payload.cumulativeAmount)),
+            signature: payload.signature,
+        }, channel.authorizedSigner);
+        return verified ? { channelId, channel } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Resolves the channel ID used to build server-side session bootstrap hints. */
 export async function resolveSessionChannelId(parameters) {
     const { capturedRequest, credential, request, resolveChannelId, source, store } = parameters;
@@ -47,10 +69,10 @@ export async function resolveSessionChannelId(parameters) {
 }
 /** Builds server bootstrap hints for a reusable precompile session channel. */
 export async function resolveSessionSnapshot(parameters) {
-    const { amount, channelId, expected, store } = parameters;
+    const { amount, channelId, expected, matchPaymentFields, store } = parameters;
     if (!channelId)
         return undefined;
-    const channel = await store.getChannel(ChannelStore.normalizeChannelId(channelId));
+    const channel = parameters.channel ?? (await store.getChannel(ChannelStore.normalizeChannelId(channelId)));
     if (!channel || !ChannelStore.isPrecompileState(channel))
         return undefined;
     if (channel.finalized)
@@ -61,8 +83,18 @@ export async function resolveSessionSnapshot(parameters) {
         return undefined;
     if (channel.highestVoucher.cumulativeAmount !== channel.highestVoucherAmount)
         return undefined;
-    if (expected && !matchesSnapshotPaymentFields(channel, expected))
-        return undefined;
+    if (expected && !matchesSnapshotPaymentFields(channel, expected)) {
+        // The snapshot is an optional reuse hint: a failing matcher (for example a
+        // transient RPC error during the route check) must omit the hint rather
+        // than fail challenge issuance or bootstrap preflight.
+        let matched = false;
+        try {
+            matched = (await matchPaymentFields?.(channel, expected)) ?? false;
+        }
+        catch { }
+        if (!matched)
+            return undefined;
+    }
     const requiredCumulative = channel.spent + amount;
     return {
         acceptedCumulative: channel.highestVoucherAmount.toString(),
@@ -115,6 +147,9 @@ function isCanonicalSessionMethodDetails(value) {
         typeof value.escrowContract === 'string' &&
         isAddress(value.escrowContract, { strict: false }) &&
         (value.feePayer === undefined || typeof value.feePayer === 'boolean') &&
+        (value.feeToken === undefined ||
+            (typeof value.feeToken === 'string' && isAddress(value.feeToken, { strict: false }))) &&
+        (value.machineTokenEnabled === undefined || typeof value.machineTokenEnabled === 'boolean') &&
         (value.minVoucherDelta === undefined || typeof value.minVoucherDelta === 'string') &&
         (value.operator === undefined ||
             (typeof value.operator === 'string' && isAddress(value.operator, { strict: false }))) &&
@@ -156,7 +191,7 @@ export async function resolveRequestChainId(parameters) {
 }
 /** Resolves request-time TIP-1034 details and server bootstrap hints for a challenge. */
 export async function resolveSessionPaymentRequest(parameters) {
-    const { capturedRequest, credential, decimals, defaultFeePayer, getClient, parameterChainId, parameterEscrowContract, parameterFeePayer, request, resolveChannelId, source, store, } = parameters;
+    const { capturedRequest, credential, decimals, defaultFeePayer, getClient, matchSnapshotPaymentFields, parameterChainId, parameterEscrowContract, parameterFeePayer, request, resolveChannelId, source, store, } = parameters;
     const chainId = await resolveRequestChainId({
         getClient,
         parameterChainId,
@@ -170,16 +205,24 @@ export async function resolveSessionPaymentRequest(parameters) {
     const escrowContract = resolveRequestEscrowContract(request.escrowContract, parameterEscrowContract);
     const operator = resolveRequestOperator(request.operator);
     const requestAmount = parseUnits(request.amount, decimals);
-    const channelId = await resolveSessionChannelId({
-        capturedRequest,
-        credential,
-        request,
-        resolveChannelId,
-        source,
-        store,
-    });
+    // A close credential names the channel it settles; advertising that channel's
+    // snapshot on the retry challenge lets clients without a configured
+    // `resolveChannelId` learn the exact capture amount a machine-token close
+    // voucher must match. Only trusted once the voucher signature verifies, and
+    // matched with close semantics so retired routes stay closable.
+    const verifiedClose = await verifiedCloseCredentialChannel(credential, store);
+    const channelId = verifiedClose?.channelId ??
+        (await resolveSessionChannelId({
+            capturedRequest,
+            credential,
+            request,
+            resolveChannelId,
+            source,
+            store,
+        }));
     const sessionSnapshot = await resolveSessionSnapshot({
         amount: capturedRequest && !isSessionContentRequest(capturedRequest) ? 0n : requestAmount,
+        channel: verifiedClose?.channel,
         channelId,
         expected: {
             chainId,
@@ -187,6 +230,9 @@ export async function resolveSessionPaymentRequest(parameters) {
             escrowContract,
             recipient: readChallengeAddress(request.recipient, 'recipient'),
         },
+        matchPaymentFields: matchSnapshotPaymentFields && (verifiedClose || request.machineTokenEnabled)
+            ? (channel, expected) => matchSnapshotPaymentFields(channel, expected, verifiedClose ? { action: 'close' } : undefined)
+            : undefined,
         store,
     });
     const { operator: _operator, ...requestWithoutOperator } = request;

package/dist/tempo/session/server/Session.d.ts

@@ -18,7 +18,9 @@ import * as Transport from '../../server/internal/transport.js';
 import { deserializeSnapshot as deserializeSessionSnapshot, serializeSnapshot as serializeSessionSnapshot } from '../Snapshot.js';
 import * as ChannelStore from './ChannelStore.js';
 import { type ResolveSessionChannelId } from './RequestState.js';
+import { type SettleChargedSessionChannel } from './Settlement.js';
 import { type OnSessionSettlement, type SettlementSchedule } from './Settlement.js';
+import * as Ws from './Ws.js';
 /** Server-side automatic settlement schedule. */
 export type { SettlementSchedule } from './Settlement.js';
 /** Server-side settlement event hook types. */
@@ -31,9 +33,10 @@ export declare function session<const parameters extends session.Parameters>(p?:
     readonly name: "tempo";
     readonly intent: "session";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"open">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 authorizedSigner: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
@@ -50,19 +53,22 @@ export declare function session<const parameters extends session.Parameters>(p?:
                 type: import("zod/mini").ZodMiniLiteral<"transaction">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"voucher">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../precompile/Protocol.js").ChannelDescriptor, import("../precompile/Protocol.js").ChannelDescriptor>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"close">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../precompile/Protocol.js").ChannelDescriptor, import("../precompile/Protocol.js").ChannelDescriptor>>;
+                refundSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>], "action">;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
             amount: import("zod/mini").ZodMiniString<string>;
             chainId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
             channelId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -70,6 +76,8 @@ export declare function session<const parameters extends session.Parameters>(p?:
             decimals: import("zod/mini").ZodMiniNumber<number>;
             escrowContract: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             feePayer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniBoolean<boolean>, import("zod/mini").ZodMiniCustom<import("viem").Account, import("viem").Account>]>, import("zod/mini").ZodMiniTransform<boolean, boolean | import("viem").Account>>>;
+            feeToken: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             minVoucherDelta: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             operator: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -81,42 +89,55 @@ export declare function session<const parameters extends session.Parameters>(p?:
             suggestedDeposit: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             unitType: import("zod/mini").ZodMiniString<string>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: string;
+            recipient?: string | undefined;
+            unitType: string;
+            amount: string;
+            suggestedDeposit?: string | undefined;
             methodDetails: {
-                sessionSnapshot?: import("../Snapshot.js").SessionSnapshot | undefined;
-                sessionProtocol?: "v1" | "v2" | undefined;
-                operator?: string | undefined;
-                feePayer?: boolean | undefined;
-                chainId?: number | undefined;
-                minVoucherDelta?: string | undefined;
-                channelId?: string | undefined;
                 escrowContract: string | undefined;
+                channelId?: string | undefined;
+                minVoucherDelta?: string | undefined;
+                chainId?: number | undefined;
+                feePayer?: boolean | undefined;
+                feeToken?: string | undefined;
+                machineTokenEnabled?: boolean | undefined;
+                operator?: string | undefined;
+                sessionProtocol?: "v1" | "v2" | undefined;
+                sessionSnapshot?: import("../Snapshot.js").SessionSnapshot | undefined;
             };
-            suggestedDeposit?: string | undefined;
-            amount: string;
-            currency: string;
-            unitType: string;
-            recipient?: string | undefined;
         }, {
             amount: string;
-            currency: string;
-            decimals: number;
-            unitType: string;
             chainId?: number | undefined;
             channelId?: string | undefined;
+            currency: string;
+            decimals: number;
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
+            feeToken?: string | undefined;
+            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;
             sessionProtocol?: "v1" | "v2" | undefined;
             sessionSnapshot?: import("../Snapshot.js").SessionSnapshot | undefined;
             suggestedDeposit?: string | undefined;
+            unitType: string;
         }>>;
     };
-}, session.DeriveDefaults<parameters>, parameters["sse"] extends false | undefined ? undefined : Transport.Sse, {}, undefined>;
+}, session.DeriveDefaults<parameters>, parameters["sse"] extends false | undefined ? undefined : Transport.Sse, session.Extensions, undefined>;
 export declare namespace session {
     const serializeSnapshot: typeof serializeSessionSnapshot;
     const deserializeSnapshot: typeof deserializeSessionSnapshot;
+    /** Extensions attached to the Tempo session method handler. */
+    type Extensions = {
+        /** Applies the configured automatic settlement policy to a committed channel charge. */
+        settleScheduled: SettleChargedSessionChannel;
+        /** Serves a WebSocket route from this handler using its configured store and settlement policy. */
+        serveWebSocket: (options: ServeWebSocketOptions) => Promise<void>;
+    };
+    /** WebSocket server options supplied after the session binds shared dependencies. */
+    type ServeWebSocketOptions = Omit<Ws.serve.Options, 'onChargeCommitted' | 'settleScheduled' | 'store'>;
     /** Request defaults inferred from the Tempo session method schema. */
     type Defaults = LooseOmit<Method.RequestDefaults<typeof Methods.session>, 'escrowContract' | 'feePayer' | 'recipient'>;
     /** Partial fee-sponsor policy used for server-submitted session transactions. */
@@ -154,17 +175,19 @@ export declare namespace session {
         store?: Store.AtomicStore | undefined;
         /** Enable SSE streaming. Pass `true` for defaults or an options object to configure SSE. */
         sse?: boolean | Transport.sse.Options | undefined;
-        /** Tempo chain ID used for TIP-1034 channel escrow challenges. Defaults to the resolved client chain ID. Pass the Tempo testnet chain ID here instead of using legacy session's `testnet` boolean. */
+        /** Tempo chain ID used for TIP-1034 channel escrow challenges. Defaults to the resolved client chain ID. */
         chainId?: number | undefined;
-        /** TIP20EscrowChannel precompile address override. */
+        /** Escrow contract advertised to clients. Defaults to the canonical TIP20EscrowChannel address. */
         escrowContract?: Address | undefined;
         /** Callback invoked after any on-chain settlement or close transaction is confirmed. */
         onSessionSettlement?: OnSessionSettlement | undefined;
         /** Server-owned automatic settlement cadence. Clients do not receive or control this schedule. */
         settlementSchedule?: SettlementSchedule | undefined;
-        /** Optional fee token used for server-driven close transactions. */
+        /** Optional fee token for management and server-driven settle/close transactions. */
         feeToken?: Address | undefined;
-    } & Account.resolve.Parameters & Client.getResolver.Parameters & Defaults;
+        /** Enables first-party machine-token funding when the configured deployment is available. */
+        machineTokenEnabled?: boolean | undefined;
+    } & Account.resolve.Parameters & Client.getResolver.Parameters & Defaults & Method.ComposableHooks<typeof Methods.session>;
     /** Defaults derived from `session()` parameters for handler type inference. */
     type DeriveDefaults<parameters extends Parameters> = types.DeriveDefaults<parameters, Defaults, {
         currency: string;

package/dist/tempo/session/server/Session.js

@@ -5,7 +5,7 @@
  * and one-shot settlement. Each incoming request carries a session credential
  * with a cumulative voucher that the server validates and records.
  */
-import { isAddress } from 'viem';
+import { isAddress, isAddressEqual } from 'viem';
 import { tempo as tempo_chain } from 'viem/chains';
 import * as Challenge from '../../../Challenge.js';
 import * as Constants from '../../../Constants.js';
@@ -16,19 +16,21 @@ import * as Store from '../../../Store.js';
 import * as Client from '../../../viem/Client.js';
 import * as Account from '../../internal/account.js';
 import * as defaults from '../../internal/defaults.js';
+import * as MachineTokenSession from '../../internal/machine-token-session.js';
 import * as Methods from '../../Methods.js';
 import * as ChargeServer from '../../server/Charge.js';
 import * as Transport from '../../server/internal/transport.js';
 import { tip20ChannelEscrow } from '../precompile/Protocol.js';
 import { deserializeSnapshot as deserializeSessionSnapshot, serializeSnapshot as serializeSessionSnapshot, } from '../Snapshot.js';
 import * as ChannelStore from './ChannelStore.js';
-import { verifyCredentialPayload } from './CredentialVerification.js';
+import { broadcastCredentialPayload, validateCredentialPayload } from './CredentialVerification.js';
 import { requireSessionCredentialPayload } from './CredentialVerification.js';
 import { resolveCredentialVerificationContext, resolveSessionChannelId, resolveSessionSnapshot, resolveSessionPaymentRequest, } from './RequestState.js';
 import { respondToSessionCredential } from './RequestState.js';
-import { applyVerifiedHttpAccounting, chargeSessionChannel } from './Settlement.js';
-import { maybeSettleScheduled } from './Settlement.js';
+import { applyVerifiedHttpAccounting, chargeSessionChannel, } from './Settlement.js';
+import { isSettlementDue, maybeSettleScheduled } from './Settlement.js';
 import { resolveSettlementSchedule, } from './Settlement.js';
+import * as Ws from './Ws.js';
 export { settle, settleBatch } from './Settlement.js';
 function deriveServerDefaults(values) {
     // `Method.toServer()` models defaults from request input fields. Tempo session
@@ -177,6 +179,9 @@ async function handleBootstrapPreflight(parameters) {
             escrowContract: resolveBootstrapEscrowContract(parameters.paymentRequest, parameters.parameterEscrowContract),
             recipient: readBootstrapAddress(request.recipient, 'recipient'),
         },
+        matchPaymentFields: parameters.paymentRequest.machineTokenEnabled
+            ? parameters.matchSnapshotPaymentFields
+            : undefined,
         store: parameters.store,
     });
     const headers = new Headers({ 'Cache-Control': 'no-store' });
@@ -189,19 +194,53 @@ async function handleBootstrapPreflight(parameters) {
 /** Creates a server-side TIP20EscrowChannel precompile session payment method. */
 export function session(p) {
     const parameters = p;
-    const { amount, channelStateTtl = 5_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, operator, store: rawStore = Store.memory(), suggestedDeposit, unitType, } = parameters;
+    const { amount, channelStateTtl = 5_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, machineTokenEnabled, operator, store: rawStore = Store.memory(), suggestedDeposit, unitType, } = parameters;
     const settlementSchedule = resolveSettlementSchedule(parameters.settlementSchedule, decimals);
     const onSessionSettlement = parameters.onSessionSettlement;
     const store = ChannelStore.fromStore(rawStore);
     const lastOnChainVerified = new Map();
     const { account, feePayer, feePayerUrl, recipient } = Account.resolve(parameters);
     const configuredFeePayer = feePayer ?? feePayerUrl;
+    const settlementFeePayer = feePayer ?? (feePayerUrl ? true : undefined);
     const getClient = Client.getResolver({
         chain: tempo_chain,
         feePayerUrl,
         getClient: parameters.getClient,
         rpcUrl: defaults.rpcUrl,
     });
+    const matchSnapshotPaymentFields = async (channel, expected, options) => {
+        if (channel.chainId !== expected.chainId ||
+            !isAddressEqual(channel.escrowContract, expected.escrowContract) ||
+            !isAddressEqual(expected.escrowContract, tip20ChannelEscrow))
+            return false;
+        return !!(await MachineTokenSession.matchRoute(await getClient({ chainId: expected.chainId }), {
+            active: options?.action !== 'close',
+            chainId: expected.chainId,
+            descriptor: channel.descriptor,
+            merchant: expected.recipient,
+            targetToken: expected.currency,
+        }));
+    };
+    const settleScheduled = async (channel) => {
+        if (!isSettlementDue(channel, settlementSchedule))
+            return undefined;
+        return maybeSettleScheduled({
+            account,
+            channel,
+            client: await getClient({ chainId: channel.chainId }),
+            ...(settlementFeePayer ? { feePayer: settlementFeePayer } : {}),
+            feePayerPolicy: parameters.feePayerPolicy,
+            feeToken: parameters.feeToken,
+            onSessionSettlement,
+            schedule: settlementSchedule,
+            store,
+        });
+    };
+    const serveWebSocket = (options) => Ws.serve({
+        ...options,
+        onChargeCommitted: settleScheduled,
+        store,
+    });
     const bootstrapCharge = ChargeServer.charge({
         account,
         chainId: parameters.chainId,
@@ -214,20 +253,110 @@ export function session(p) {
     });
     const transport = parameters.sse
         ? Transport.sse({
+            settleCharged: settleScheduled,
             store,
             ...(typeof parameters.sse === 'object' ? parameters.sse : undefined),
         })
         : undefined;
-    return Method.toServer(Methods.session, {
+    const validateCredential = async ({ credential, request, }) => {
+        const payload = requireSessionCredentialPayload(credential.payload);
+        const context = await resolveCredentialVerificationContext({
+            decimals,
+            feePayer: configuredFeePayer,
+            getClient,
+            minVoucherDelta: parameters.minVoucherDelta,
+            request,
+        });
+        const details = await validateCredentialPayload({
+            account,
+            challenge: credential.challenge,
+            channelStateTtl,
+            chainId: context.chainId,
+            client: context.client,
+            credentialSource: credential.source,
+            escrow: context.escrow,
+            expectedOperator: context.methodDetails.operator,
+            feePayer: context.feePayer,
+            feePayerPolicy: parameters.feePayerPolicy,
+            feeToken: context.methodDetails.feeToken,
+            lastOnChainVerified,
+            minVoucherDelta: context.minVoucherDelta,
+            payload,
+            store,
+        });
+        return {
+            challenge: credential.challenge,
+            credential: { ...credential, payload },
+            details,
+            intent: 'session',
+            method: 'tempo',
+            request: context.request,
+            source: credential.source,
+        };
+    };
+    const broadcastCredential = async ({ credential, envelope, request, }) => {
+        const { challenge } = credential;
+        const payload = requireSessionCredentialPayload(credential.payload);
+        const context = await resolveCredentialVerificationContext({
+            decimals,
+            feePayer: configuredFeePayer,
+            getClient,
+            minVoucherDelta: parameters.minVoucherDelta,
+            request,
+        });
+        const sessionReceipt = await broadcastCredentialPayload({
+            account,
+            challenge,
+            channelStateTtl,
+            chainId: context.chainId,
+            client: context.client,
+            credentialSource: credential.source,
+            escrow: context.escrow,
+            expectedOperator: context.methodDetails.operator,
+            feePayer: context.feePayer,
+            feePayerPolicy: parameters.feePayerPolicy,
+            feeToken: context.methodDetails.feeToken,
+            lastOnChainVerified,
+            minVoucherDelta: context.minVoucherDelta,
+            onSessionSettlement,
+            payload,
+            store,
+        });
+        return applyVerifiedHttpAccounting({
+            capturedRequest: envelope?.capturedRequest,
+            payloadAction: payload.action,
+            receipt: sessionReceipt,
+            getRequestAmount: () => BigInt(context.request.amount ?? challenge.request.amount),
+            sseEnabled: Boolean(parameters.sse),
+            markPrepaidReceipt: Transport.markPrepaidSessionTick,
+            charge: (channelId, requestAmount) => chargeSessionChannel({ store, channelId, amount: requestAmount }),
+            settleCharged: (channel) => maybeSettleScheduled({
+                account,
+                client: context.client,
+                ...(context.feePayer ? { feePayer: context.feePayer } : {}),
+                feePayerPolicy: parameters.feePayerPolicy,
+                feeToken: parameters.feeToken,
+                onSessionSettlement,
+                schedule: settlementSchedule,
+                store,
+                channel,
+            }),
+        });
+    };
+    const method = Method.toServer(Methods.session, {
+        canOffer: parameters.canOffer,
+        onPaymentSuccess: parameters.onPaymentSuccess,
         defaults: deriveServerDefaults({
             amount,
             currency,
             decimals,
+            machineTokenEnabled,
             operator,
             recipient,
             suggestedDeposit,
             unitType,
         }),
+        extensions: { serveWebSocket, settleScheduled },
         transport: deriveTransport(transport),
         preflight: parameters.bootstrap
             ? async ({ capturedRequest, credential, expires, input, options, realm, secretKey }) => {
@@ -242,6 +371,7 @@ export function session(p) {
                     defaultRecipient: recipient,
                     expires,
                     getClient,
+                    matchSnapshotPaymentFields,
                     parameterChainId: parameters.chainId,
                     parameterEscrowContract: parameters.escrowContract,
                     paymentRequest: options,
@@ -259,6 +389,7 @@ export function session(p) {
                 decimals,
                 defaultFeePayer: feePayer,
                 getClient,
+                matchSnapshotPaymentFields,
                 parameterChainId: parameters.chainId,
                 parameterEscrowContract: parameters.escrowContract,
                 parameterFeePayer: parameters.feePayer,
@@ -266,60 +397,22 @@ export function session(p) {
                 resolveChannelId: parameters.resolveChannelId,
                 store,
             });
+            // Only advertise the capability when this logical session can use a
+            // configured unified router on the canonical escrow.
+            const { machineTokenEnabled: requestedMachineTokenEnabled, ...requestWithoutMachineToken } = resolvedRequest;
+            const machineSessionSupported = MachineTokenSession.isSupported(resolvedRequest.chainId) &&
+                isAddressEqual(resolvedRequest.escrowContract, tip20ChannelEscrow);
             return {
-                ...resolvedRequest,
+                ...requestWithoutMachineToken,
+                feeToken: parameters.feeToken,
+                ...(requestedMachineTokenEnabled && machineSessionSupported
+                    ? { machineTokenEnabled: true }
+                    : {}),
                 sessionProtocol: Constants.SessionProtocols.v2,
             };
         },
-        async verify({ credential, envelope, request }) {
-            const { challenge } = credential;
-            const payload = requireSessionCredentialPayload(credential.payload);
-            const context = await resolveCredentialVerificationContext({
-                decimals,
-                feePayer: configuredFeePayer,
-                getClient,
-                minVoucherDelta: parameters.minVoucherDelta,
-                request,
-            });
-            const sessionReceipt = await verifyCredentialPayload({
-                account,
-                challenge,
-                channelStateTtl,
-                chainId: context.chainId,
-                client: context.client,
-                credentialSource: credential.source,
-                escrow: context.escrow,
-                expectedOperator: context.methodDetails.operator,
-                feePayer: context.feePayer,
-                feePayerPolicy: parameters.feePayerPolicy,
-                feeToken: parameters.feeToken,
-                lastOnChainVerified,
-                minVoucherDelta: context.minVoucherDelta,
-                onSessionSettlement,
-                payload,
-                store,
-            });
-            return applyVerifiedHttpAccounting({
-                capturedRequest: envelope?.capturedRequest,
-                payloadAction: payload.action,
-                receipt: sessionReceipt,
-                getRequestAmount: () => BigInt(context.request.amount ?? challenge.request.amount),
-                sseEnabled: Boolean(parameters.sse),
-                markPrepaidReceipt: Transport.markPrepaidSessionTick,
-                charge: (channelId, requestAmount) => chargeSessionChannel({ store, channelId, amount: requestAmount }),
-                settleCharged: (channel) => maybeSettleScheduled({
-                    account,
-                    client: context.client,
-                    ...(typeof context.feePayer === 'object' ? { feePayer: context.feePayer } : {}),
-                    feePayerPolicy: parameters.feePayerPolicy,
-                    feeToken: parameters.feeToken,
-                    onSessionSettlement,
-                    schedule: settlementSchedule,
-                    store,
-                    channel,
-                }),
-            });
-        },
+        validate: validateCredential,
+        broadcast: broadcastCredential,
         // This hook acts as a gate: when it returns a Response, `withReceipt()`
         // in Mppx.ts short-circuits and returns that response directly without
         // invoking the user's route handler. When it returns undefined, the
@@ -338,6 +431,7 @@ export function session(p) {
             });
         },
     });
+    return method;
 }
 (function (session) {
     session.serializeSnapshot = serializeSessionSnapshot;