mppx 0.17.0 → 0.17.3

package/dist/tempo/server/internal/transport.d.ts

@@ -4,11 +4,13 @@ import * as ChannelStore from '../../session/server/ChannelStore.js';
 import type { SettleChargedSessionChannel } from '../../session/server/Settlement.js';
 import * as Sse_core from '../../session/server/Sse.js';
 declare const prepaidSessionTick: unique symbol;
+declare const prepaidRefundKey: unique symbol;
 /** SSE transport with Tempo session controller. */
 export type Sse = Transport.Sse<Sse_core.SessionController>;
 /** Receipt marker used to avoid double-charging a request already charged during verification. */
 export type PrepaidSessionReceipt = SessionReceipt & {
     [prepaidSessionTick]?: true | undefined;
+    [prepaidRefundKey]?: string | undefined;
 };
 /** Marks a session receipt as already charged for the current request. */
 export declare function markPrepaidSessionTick(receipt: SessionReceipt): SessionReceipt;
@@ -42,6 +44,10 @@ export declare namespace sse {
          * @default false
          */
         poll?: boolean | undefined;
+        /** Opt in to SDK-owned prepaid credits; leave false with an existing merchant refund handler. */
+        autoCreditPrepaid?: boolean | undefined;
+        /** Merchant reconciliation hook for prepaid items that fail before delivery; see `Sse.serve.Options.onRefundRequired`. */
+        onRefundRequired?: Sse_core.serve.Options['onRefundRequired'];
         /** Polling interval (in milliseconds). @default 10 */
         pollingInterval?: number | undefined;
     };

package/dist/tempo/server/internal/transport.js

@@ -14,8 +14,15 @@ import * as ChannelStore from '../../session/server/ChannelStore.js';
 import * as Sse_core from '../../session/server/Sse.js';
 import { captureRequestBodyProbe, shouldChargePlainResponse } from './request-body.js';
 const prepaidSessionTick = Symbol('mppx.prepaidSessionTick');
+const consumedPrepaidReceipts = new WeakSet();
+const prepaidRefundKey = Symbol('mppx.prepaidRefundKey');
 /** Marks a session receipt as already charged for the current request. */
 export function markPrepaidSessionTick(receipt) {
+    if (hasPrepaidSessionTick(receipt))
+        return receipt;
+    Object.defineProperty(receipt, prepaidRefundKey, {
+        value: `stream:${globalThis.crypto.randomUUID()}`,
+    });
     Object.defineProperty(receipt, prepaidSessionTick, {
         configurable: false,
         enumerable: false,
@@ -65,6 +72,11 @@ export function sse(options) {
             return base.respondChallenge(options);
         },
         async respondReceipt({ credential, envelope, receipt, response, challengeId, input }) {
+            if (hasPrepaidSessionTick(receipt)) {
+                if (consumedPrepaidReceipts.has(receipt))
+                    throw new Error('Prepaid receipt already used; verify a new payment before retrying delivery');
+                consumedPrepaidReceipts.add(receipt);
+            }
             const verifiedCredential = envelope?.credential ?? credential;
             const verifiedChallengeId = envelope?.challenge.id ?? challengeId;
             const verifiedRequest = envelope?.request ?? verifiedCredential.challenge.request;
@@ -86,20 +98,25 @@ export function sse(options) {
                 // Pass async generator functions directly so Sse.serve gives them
                 // a SessionController for manual charge(). Pass raw AsyncIterables
                 // as-is so Sse.serve auto-charges per yielded value.
-                const generate = resolveMeteredGenerate(resolved, unitType);
-                const stream = Sse_core.serve({
+                const generate = resolved;
+                const streamOptions = {
                     store,
                     channelId,
                     challengeId: verifiedChallengeId,
                     tickCost,
                     pollIntervalMs: pollingInterval,
                     generate,
+                    chargeOnce: unitType === 'request',
                     beforeCharge: () => options.beforeCharge?.(channelId),
                     onChargeCommitted: options.settleCharged,
                     prepaidUnits: hasPrepaidSessionTick(receipt) ? 1 : 0,
+                    refundIdempotencyKey: receipt[prepaidRefundKey],
+                    onRefundRequired: options.onRefundRequired,
+                    autoCreditPrepaid: options.autoCreditPrepaid,
                     signal: input.signal,
-                });
-                return Sse_core.toResponse(stream);
+                };
+                await Sse_core.preparePrepaidRefund(streamOptions);
+                return Sse_core.toResponse(Sse_core.serve(streamOptions));
             }
             const baseResponse = base.respondReceipt({
                 credential: verifiedCredential,
@@ -246,23 +263,6 @@ function isAsyncGeneratorFunction(value) {
 function isAsyncIterable(value) {
     return value !== null && typeof value === 'object' && Symbol.asyncIterator in value;
 }
-function resolveMeteredGenerate(value, unitType) {
-    if (isAsyncGeneratorFunction(value))
-        return value;
-    if (unitType !== 'request')
-        return value;
-    const iterable = value;
-    return async function* chargeOnce(stream) {
-        let charged = false;
-        for await (const chunk of iterable) {
-            if (!charged) {
-                await stream.charge();
-                charged = true;
-            }
-            yield chunk;
-        }
-    };
-}
 function isNullBodyStatus(status) {
     return [101, 204, 205, 304].includes(status);
 }

package/dist/tempo/session/client/ChannelOps.d.ts

@@ -19,6 +19,8 @@ export type TempoChannelCall = {
 };
 /** Client-side cached channel metadata used for automatic voucher management. */
 export type ChannelEntry = {
+    /** HTTP origin bound by a session manager; absent on legacy or standalone method entries. */
+    origin?: string | undefined;
     /** TIP-1034 channel ID derived from descriptor, escrow, and chain ID. */
     channelId: Hex.Hex;
     /** Highest cumulative amount this client has locally authorized. */

package/dist/tempo/session/client/ChannelStore.d.ts

@@ -15,6 +15,8 @@ export type ChannelStore = {
 };
 /** Channel persistence and update notification for credential results. */
 export type ChannelSink = {
+    /** Origin attached to newly created or recovered channels before persistence. */
+    origin?: string | undefined;
     store: ChannelStore;
     notifyUpdate: (entry: ChannelEntry) => void;
 };

package/dist/tempo/session/client/ChannelStore.js

@@ -91,6 +91,11 @@ export function withFundingLock(store, key, operation) {
 export async function persistChannel(store, entry) {
     await exclusive(store, `write:${entryKey(entry)}`, async () => {
         const current = await store.get(entryKey(entry));
+        if (current?.origin !== undefined) {
+            if (entry.origin !== undefined && entry.origin !== current.origin)
+                throw new Error('SessionManager: stored channel origin mismatch');
+            entry.origin = current.origin;
+        }
         if (current?.uncertainTopUp) {
             if (current.channelId !== entry.channelId)
                 throw new Error('Session funding outcome is unknown; reconcile the pending payment before replacing the channel.');

package/dist/tempo/session/client/CredentialState.js

@@ -25,6 +25,8 @@ export function readCredentialCumulativeAmount(payload) {
  * can react to the close.
  */
 async function storeChannelEntry(sink, entry) {
+    if (sink.origin !== undefined)
+        entry = { ...entry, origin: sink.origin };
     if (entry.opened)
         await persistChannel(sink.store, entry);
     else

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

@@ -132,9 +132,32 @@ export declare namespace session {
         allowCustomEscrow?: boolean | undefined;
         /** Automatically acquire the session currency from fallback stablecoins before open/top-up. */
         autoSwap?: AutoSwap.resolve.Value | undefined;
-        /** Pluggable persistence for reusable channels. Defaults to an in-memory store. */
+        /**
+         * HTTP origin authorized for credential creation and server-snapshot recovery.
+         * Fetch supplies the request origin, but recovering an unknown channel from its snapshot
+         * requires this explicit origin pin or a caller-supplied descriptor.
+         */
+        origin?: string | undefined;
+        /**
+         * Pluggable persistence for reusable channels. Defaults to an in-memory store.
+         * Use a separate store per HTTP origin: each payment scope holds one channel, and a
+         * channel already bound to another origin is rejected rather than overwritten or reused.
+         */
         channelStore?: ChannelStore | undefined;
-        /** Token decimals for parsing human-readable amounts (default: 6). */
+        /**
+         * Allowlist of TIP-20 currency addresses this client will pay sessions in, compared
+         * case-insensitively. Offers in other currencies are skipped during selection and
+         * rejected before signing; an empty list rejects all. Required with `maxAmount` or
+         * `maxAtomicAmount`, which are denominated in the challenge currency.
+         */
+        currencies?: readonly Address[] | undefined;
+        /**
+         * Allowlist of session recipients (the channel payee), compared case-insensitively. Offers
+         * to other recipients, or without one, are skipped during selection and rejected before
+         * signing, as for charge. Explicit closes are exempt.
+         */
+        expectedRecipients?: readonly Address[] | undefined;
+        /** Token decimals for parsing human-readable amounts (default: 6). `maxAmount` requires it explicitly. */
         decimals?: number | undefined;
         /** Exact TIP20EscrowChannel address pin. Takes precedence over `allowCustomEscrow`. */
         escrow?: Address | undefined;
@@ -144,6 +167,18 @@ export declare namespace session {
          * challenge or resolved client must select an allowed chain.
          */
         allowedChainIds?: readonly number[] | undefined;
+        /**
+         * Maximum display-unit amount (e.g. `'1.5'`) the client is willing to pay per session
+         * unit (the challenge `amount`), parsed with an explicit `decimals`. Values with more
+         * fractional digits than `decimals` are rejected rather than rounded. Larger offers are
+         * skipped during selection and rejected before signing. Requires `currencies`.
+         */
+        maxAmount?: string | undefined;
+        /**
+         * Maximum amount the client is willing to pay per session unit, in raw base units of the
+         * challenge currency. Checked like `maxAmount`. Requires `currencies`.
+         */
+        maxAtomicAmount?: string | undefined;
         /** Maximum channel deposit in human-readable units. Caps server-suggested opens and automatic top-ups. */
         maxDeposit?: string | undefined;
         /**

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

@@ -4,6 +4,7 @@ import * as MethodChallenge from '../../../client/internal/MethodChallenge.js';
 import * as MethodResponse from '../../../client/internal/MethodResponse.js';
 import * as Constants from '../../../Constants.js';
 import * as Credential from '../../../Credential.js';
+import * as AcceptPayment from '../../../internal/AcceptPayment.js';
 import * as Method from '../../../Method.js';
 import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
@@ -69,6 +70,65 @@ function acknowledgesOpen(outcome, challenge, opened) {
         return matchesOpen(opened, getSessionSnapshot(candidate));
     }) ?? false);
 }
+/** Validates and parses the client's session spending options once, at construction. */
+function resolveSpendingPolicy(parameters) {
+    const { currencies, decimals, expectedRecipients, maxAmount, maxAtomicAmount } = parameters;
+    // Caps are denominated in the challenge currency, so they require a currency pin.
+    if ((maxAmount !== undefined || maxAtomicAmount !== undefined) && currencies === undefined)
+        throw new Error('Tempo session maxAmount and maxAtomicAmount require currencies.');
+    return {
+        currencies: currencies?.map((currency) => currency.toLowerCase()),
+        expectedRecipients: expectedRecipients
+            ? new Set(expectedRecipients.map((recipient) => recipient.toLowerCase()))
+            : undefined,
+        maxAmount: parseMaxAmount(maxAmount, decimals),
+        maxAtomicAmount: maxAtomicAmount === undefined ? undefined : BigInt(maxAtomicAmount),
+    };
+}
+/** Parses a display-unit cap, rejecting values that `parseUnits` would round. */
+function parseMaxAmount(maxAmount, decimals) {
+    if (maxAmount === undefined)
+        return undefined;
+    if (decimals === undefined)
+        throw new Error('Tempo session maxAmount requires currency decimals.');
+    const fraction = maxAmount.split('.')[1]?.replace(/0+$/, '') ?? '';
+    if (fraction.length > decimals)
+        throw new Error(`Tempo session maxAmount ${maxAmount} has more fractional digits than ${decimals} decimals allow.`);
+    return parseUnits(maxAmount, decimals);
+}
+/**
+ * Rejects a session challenge whose currency, recipient or per-unit amount violates the client
+ * policy. Runs during challenge selection, in the automatic top-up hook, and before any signing work.
+ */
+function assertSpendingPolicy(policy, request) {
+    if (policy.currencies && !policy.currencies.includes(request.currency.toLowerCase()))
+        throw new Error(`Tempo session currency is not allowed: ${request.currency}.`);
+    // The recipient is the channel payee, so it must be one the client expects, as for charge.
+    if (policy.expectedRecipients &&
+        (!request.recipient || !policy.expectedRecipients.has(request.recipient.toLowerCase())))
+        throw new Error(`Unexpected session recipient: ${request.recipient}`);
+    const amount = BigInt(request.amount);
+    if (policy.maxAtomicAmount !== undefined && amount > policy.maxAtomicAmount)
+        throw new Error('Tempo session amount exceeds maxAtomicAmount.');
+    if (policy.maxAmount !== undefined && amount > policy.maxAmount)
+        throw new Error('Tempo session amount exceeds maxAmount.');
+}
+/** Returns whether a session challenge satisfies the client policy. */
+function satisfiesSpendingPolicy(policy, request) {
+    try {
+        assertSpendingPolicy(policy, request);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Returns whether a caller-supplied credential context asks to close a channel. */
+function isExplicitClose(context) {
+    return (typeof context === 'object' &&
+        context !== null &&
+        context.action === 'close');
+}
 /**
  * Creates the low-level TIP-1034 session payment method for use with `Mppx.create()`.
  *
@@ -78,6 +138,7 @@ function acknowledgesOpen(outcome, challenge, opened) {
  */
 export function session(parameters = {}) {
     const { account, allowCustomEscrow = false, autoSwap: autoSwapParameter, channelStore, decimals = defaults.decimals, escrow: escrowOverride, allowedChainIds, getClient: getClientParameter, maxDeposit: maxDepositParameter, topUpAmount: topUpAmountParameter, onChannelUpdate, resolveAccount, } = parameters;
+    const policy = resolveSpendingPolicy(parameters);
     const getClient = Client.getResolver({
         chain: tempo_chain,
         getClient: getClientParameter,
@@ -86,6 +147,9 @@ export function session(parameters = {}) {
     const getAccount = Account.getResolver({ account });
     const maxDeposit = maxDepositParameter !== undefined ? parseUnits(maxDepositParameter, decimals) : undefined;
     const topUpAmount = topUpAmountParameter !== undefined ? parseUnits(topUpAmountParameter, decimals) : undefined;
+    const configuredOrigin = parameters.origin === undefined ? undefined : new URL(parameters.origin);
+    if (configuredOrigin && !['http:', 'https:'].includes(configuredOrigin.protocol))
+        throw new Error('Session origins require HTTP or HTTPS');
     const store = channelStore ?? createChannelStore();
     const sink = { store, notifyUpdate: (entry) => onChannelUpdate?.(entry) };
     const resolveCredentialAccount = async (resolved, context, entry) => {
@@ -112,10 +176,19 @@ export function session(parameters = {}) {
         resolved,
     });
     const method = Method.toClient(Methods.session, {
-        canHandleChallenge: ({ challenge }) => isTip1034SessionChallenge(challenge),
+        // Skip offers that violate client policy so an acceptable offer can be chosen. An explicit
+        // close, when the caller supplies it before selection, stays available for any offer. Flows
+        // that learn the context only after selection defer the policy to createCredential.
+        canHandleChallenge: ({ challenge, context }) => isTip1034SessionChallenge(challenge) &&
+            (isExplicitClose(context) ||
+                context === AcceptPayment.deferredContext ||
+                satisfiesSpendingPolicy(policy, challenge.request)),
         context: sessionContextSchema,
         async createCredential(parameters) {
             const { challenge, context } = parameters;
+            // Closing settles what the channel already spent, so it stays available for any offer.
+            if (context?.action !== 'close')
+                assertSpendingPolicy(policy, challenge.request);
             const resolved = await resolveChallengeContext({
                 allowCustomEscrow,
                 challenge,
@@ -124,6 +197,13 @@ export function session(parameters = {}) {
                 getClient,
             });
             const attempt = MethodResponse.getAttempt(parameters);
+            const origin = MethodResponse.getOrigin(parameters) ?? configuredOrigin?.origin;
+            if (origin !== undefined &&
+                (origin === 'null' || !['http:', 'https:'].includes(new URL(origin).protocol)))
+                throw new Error('Session payments require an HTTP or HTTPS origin');
+            if (configuredOrigin && origin !== configuredOrigin.origin)
+                throw new Error('Session channel origin mismatch');
+            const scopedSink = { ...sink, origin };
             let release = () => { };
             try {
                 const automatic = !hasSessionAction(context) && context?.descriptor === undefined;
@@ -133,10 +213,16 @@ export function session(parameters = {}) {
                         await attempt.prepare();
                 }
                 let entry = await store.get(resolved.key);
+                if (entry && entry.origin !== origin)
+                    throw new Error('Session channel origin mismatch');
+                if (origin && !entry && resolved.snapshot && !context?.descriptor && !configuredOrigin)
+                    throw new Error('Session snapshot recovery requires an explicitly configured origin or descriptor');
                 let plan = await resolveCredentialPlan(resolved, context, entry);
                 if (!automatic && attempt && plan.type === 'open') {
                     release = await lockChannel(store, resolved.key);
                     const nextEntry = await store.get(resolved.key);
+                    if (nextEntry && nextEntry.origin !== origin)
+                        throw new Error('Session channel origin mismatch');
                     if (nextEntry?.channelId !== entry?.channelId) {
                         entry = nextEntry;
                         if (entry?.opened) {
@@ -154,13 +240,13 @@ export function session(parameters = {}) {
                         store: {
                             get: (key) => store.get(key),
                             async set(next) {
-                                pendingOpen = next;
+                                pendingOpen = origin ? { ...next, origin } : next;
                             },
                             delete: (key) => store.delete(key),
                         },
                         notifyUpdate() { },
                     }
-                    : sink;
+                    : scopedSink;
                 const payload = await executeCredentialPlan(plan, credentialSink, AutoSwap.resolve(context?.autoSwap ?? autoSwapParameter, AutoSwap.defaultCurrencies));
                 const credential = await serializeCredential(challenge, payload, resolved.chainId, plan.account);
                 if (attempt && pendingOpen) {
@@ -195,7 +281,12 @@ export function session(parameters = {}) {
             }
         },
     });
-    const topUpChannelIfNeeded = async ({ challenge, channel, deposit, fetch, input, requiredCumulative, signal, }) => {
+    function createSessionCredential(challenge, context, input) {
+        const parameters = { challenge, context };
+        MethodResponse.attachOrigin(parameters, resolveInputOrigin(input));
+        return method.createCredential(parameters);
+    }
+    const topUpChannelIfNeeded = async ({ autoSwap, challenge, channel, deposit, fetch, input, requiredCumulative, signal, }) => {
         return withFundingLock(store, entryKey(channel), async () => {
             signal?.throwIfAborted();
             const fundingChannel = await store.get(entryKey(channel));
@@ -215,11 +306,12 @@ export function session(parameters = {}) {
             });
             if (additionalDeposit > 0n)
                 await postTopUp({
+                    autoSwap,
                     additionalDeposit,
                     challenge,
                     channel,
                     channelId: channel.channelId,
-                    createSessionCredential: (challenge, context) => method.createCredential({ challenge, context }),
+                    createSessionCredential: (challenge, context) => createSessionCredential(challenge, context, input),
                     onUncertainFunding: async (entry) => {
                         const current = await store.get(entryKey(entry));
                         const unresolved = {
@@ -252,6 +344,7 @@ export function session(parameters = {}) {
         const sessionContext = context === undefined ? undefined : sessionContextSchema.parse(context);
         if (hasSessionAction(sessionContext))
             return;
+        assertSpendingPolicy(policy, challenge.request);
         const resolved = await resolveChallengeContext({
             allowCustomEscrow,
             challenge,
@@ -262,6 +355,9 @@ export function session(parameters = {}) {
         const channel = await store.get(resolved.key);
         if (!channel?.opened)
             return;
+        const origin = resolveInputOrigin(input);
+        if (channel.origin !== origin)
+            throw new Error('Session channel origin mismatch');
         const snapshot = resolved.snapshot?.channelId.toLowerCase() === channel.channelId.toLowerCase()
             ? resolved.snapshot
             : undefined;
@@ -276,6 +372,7 @@ export function session(parameters = {}) {
         if (!canSignDescriptor(account, channel.descriptor))
             return;
         await topUpChannelIfNeeded({
+            autoSwap: sessionContext?.autoSwap,
             challenge,
             channel,
             deposit,
@@ -285,7 +382,7 @@ export function session(parameters = {}) {
             signal,
         });
     });
-    return MethodResponse.register(method, async ({ challenge, credential, fetch, headers, input, refetch, response, signal }) => {
+    return MethodResponse.register(method, async ({ challenge, context, credential, fetch, headers, input, refetch, response, signal, }) => {
         if (!isTip1034SessionChallenge(challenge))
             return response;
         if (!isEventStream(response)) {
@@ -305,13 +402,14 @@ export function session(parameters = {}) {
         let channel = await store.get(channelKey);
         const driver = {
             assertVoucherWithinLocalLimit: (cumulativeAmount) => assertWithinMaxDeposit(cumulativeAmount, maxDeposit),
-            createSessionCredential: (challenge, context) => method.createCredential({ challenge, context }),
+            createSessionCredential: (challenge, context) => createSessionCredential(challenge, context, input),
             fetch,
             getChannel: () => channel ?? null,
             async topUpIfNeeded({ deposit, requiredCumulative, signal: topUpSignal }) {
                 if (!channel)
                     return;
                 await topUpChannelIfNeeded({
+                    autoSwap: context === undefined ? undefined : sessionContextSchema.parse(context).autoSwap,
                     challenge,
                     channel,
                     deposit: channel.deposit > deposit ? channel.deposit : deposit,
@@ -330,4 +428,10 @@ export function session(parameters = {}) {
         });
     });
 }
+function resolveInputOrigin(input) {
+    const url = new URL(input instanceof Request ? input.url : input, typeof globalThis.location === 'undefined' ? undefined : globalThis.location.href);
+    if (!['http:', 'https:'].includes(url.protocol))
+        throw new Error('Session payments require an HTTP or HTTPS origin');
+    return url.origin;
+}
 //# sourceMappingURL=Session.js.map

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

@@ -60,6 +60,7 @@ export declare function mergeSessionCredentialContext(credentialContext: unknown
  * channel state management and credential creation, and to `Fetch.from`
  * for the 402 challenge/retry flow.
  *
+ * Each manager is pinned to its first request origin. Use a separate manager per origin.
  * `channelStore` can persist reusable channels between manager instances.
  */
 export declare function sessionManager(parameters: sessionManager.Parameters): SessionManager;
@@ -75,7 +76,7 @@ export declare namespace sessionManager {
         /** Enables same-route HEAD bootstrap from a server session snapshot before opening a new channel. */
         bootstrap?: boolean | undefined;
         /**
-         * Server origins allowed to request bootstrap proofs for a realm other than their hostname,
+         * Server origins allowed to request bootstrap proofs or session payments for a realm other than their hostname,
          * mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
          */
         trustedTempoProofRealms?: ProofRealm.TrustedRealms | undefined;

package/dist/tempo/session/client/SessionManager.js

@@ -7,6 +7,7 @@ import * as MethodResponse from '../../../client/internal/MethodResponse.js';
 import * as ProofRealm from '../../../client/internal/ProofRealm.js';
 import { setCredentialHeader } from '../../../client/internal/protocols/Shared.js';
 import * as Constants from '../../../Constants.js';
+import * as IdentityClient from '../../../identity/Client.js';
 import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
 import { charge as chargePlugin } from '../../client/Charge.js';
@@ -23,7 +24,7 @@ import { resolveCloseTarget } from './Runtime.js';
 import { assertVoucherWithinLocalLimit as assertVoucherWithinLocalAuthorization } from './Runtime.js';
 import { applySessionReceiptToRuntime, captureRuntimeSnapshot as captureRuntimeStateSnapshot, computeFallbackCloseAmount, createSessionManagerRuntime, dispatchSessionEvent, restoreCumulativeAuthorization, restoreRuntimeSnapshot as restoreRuntimeStateSnapshot, resolveAutomaticTopUp, } from './Runtime.js';
 import { closeSocketSession } from './Runtime.js';
-import { closeHttpSession, getSessionSnapshot, isTempoSessionChallenge, postTopUp, retryHttpPaymentRequired, webSocketProbeUrl, } from './Transports.js';
+import { closeHttpSession, getSessionSnapshot, isTempoSessionChallenge, isRequest, postTopUp, retryHttpPaymentRequired, webSocketProbeUrl, } from './Transports.js';
 import { WebSocketReadyState, } from './Transports.js';
 import { consumeSseSessionResponse, openSseSession } from './Transports.js';
 import { UncertainFundingError, applyTopUpResult, resolveManualTopUp, } from './Transports.js';
@@ -47,7 +48,7 @@ function isZeroAmountChargeChallenge(challenge) {
 function requestInitWithSessionHint(input, init, channelId) {
     if (!channelId)
         return init;
-    const requestHeaders = input instanceof Request ? input.headers : undefined;
+    const requestHeaders = isRequest(input) ? input.headers : undefined;
     const headers = {
         ...Fetch.normalizeHeaders(requestHeaders),
         ...Fetch.normalizeHeaders(init?.headers),
@@ -88,6 +89,7 @@ function resolveSessionManagerConfig(parameters) {
  * channel state management and credential creation, and to `Fetch.from`
  * for the 402 challenge/retry flow.
  *
+ * Each manager is pinned to its first request origin. Use a separate manager per origin.
  * `channelStore` can persist reusable channels between manager instances.
  */
 export function sessionManager(parameters) {
@@ -96,6 +98,34 @@ export function sessionManager(parameters) {
         Client.assertAllowedChainId(parameters.allowedChainIds, clientChainId);
     const allowCustomEscrow = parameters.allowCustomEscrow ?? false;
     const config = resolveSessionManagerConfig(parameters);
+    let sessionOrigin;
+    function bindOrigin(input) {
+        const url = new URL(isRequest(input) ? input.url : String(input), typeof location === 'undefined' ? undefined : location.href);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:')
+            throw new Error('SessionManager: session payments require an HTTP origin');
+        const origin = url.origin;
+        if (sessionOrigin !== undefined && sessionOrigin !== origin)
+            throw new Error('SessionManager: session payment origin mismatch');
+        sessionOrigin = origin;
+        return origin;
+    }
+    const inheritedIdentity = Fetch.identityOf(config.fetch);
+    const rawFetch = Fetch.unwrapFetch(config.fetch);
+    config.fetch = async (input, init) => {
+        const origin = bindOrigin(input);
+        const response = await rawFetch(input, {
+            ...init,
+            redirect: (init?.redirect ?? (isRequest(input) ? input.redirect : undefined)) === 'manual'
+                ? 'manual'
+                : 'error',
+        });
+        if (response.url && new URL(response.url).origin !== origin)
+            throw new Error('SessionManager: session response origin mismatch');
+        return response;
+    };
+    const guardedFetch = config.fetch;
+    if (inheritedIdentity)
+        config.fetch = IdentityClient.wrapFetch(guardedFetch, inheritedIdentity);
     const getClient = Client.getResolver({
         chain: tempo_chain,
         getClient: parameters.client ? () => parameters.client : parameters.getClient,
@@ -115,11 +145,19 @@ export function sessionManager(parameters) {
     /** Returns the backing entry for `key` only when it is open and not ignored. */
     async function getReusable(key) {
         const entry = await backing.get(key);
-        if (entry?.opened && !ignoredChannelIds.has(entry.channelId))
+        if (entry?.opened && !ignoredChannelIds.has(entry.channelId)) {
+            if (entry.origin !== sessionOrigin)
+                throw new Error('SessionManager: stored channel origin mismatch');
             return entry;
+        }
         return undefined;
     }
-    const persistChannel = (entry) => persistStoredChannel(backing, entry);
+    const persistChannel = (entry) => {
+        if (entry.origin !== undefined && entry.origin !== sessionOrigin)
+            throw new Error('SessionManager: stored channel origin mismatch');
+        entry.origin = sessionOrigin;
+        return persistStoredChannel(backing, entry);
+    };
     const store = {
         async get(key) {
             const entry = await getReusable(key);
@@ -252,7 +290,9 @@ export function sessionManager(parameters) {
         resolveAccount: parameters.resolveAccount,
     });
     const wrappedFetch = Fetch.from({
-        fetch: config.fetch,
+        trustedTempoProofRealms: parameters.trustedTempoProofRealms,
+        fetch: guardedFetch,
+        identity: inheritedIdentity,
         methods: [method],
         onChallenge: async (challenge, _helpers) => {
             if (!isTempoSessionChallenge(challenge))
@@ -277,10 +317,13 @@ export function sessionManager(parameters) {
         },
     });
     function createSessionCredential(challenge, context) {
-        return method.createCredential({
+        const parameters = {
             challenge,
             context: mergeSessionCredentialContext(credentialContext, context),
-        });
+        };
+        if (sessionOrigin)
+            MethodResponse.attachOrigin(parameters, sessionOrigin);
+        return method.createCredential(parameters);
     }
     function updateSpentFromReceipt(receipt) {
         applySessionReceiptToRuntime({
@@ -334,9 +377,9 @@ export function sessionManager(parameters) {
             return undefined;
         if (runtime.channel?.opened)
             return undefined;
-        const requestHeaders = input instanceof Request ? input.headers : undefined;
+        const requestHeaders = isRequest(input) ? input.headers : undefined;
         const { body: _body, method: _method, ...bootstrapInit } = init ?? {};
-        const bootstrapInput = input instanceof Request ? input.url : input;
+        const bootstrapInput = isRequest(input) ? input.url : input;
         const headInit = {
             ...bootstrapInit,
             method: 'HEAD',
@@ -646,6 +689,7 @@ export function sessionManager(parameters) {
         // corrupt each other's runtime and channel tracking.
         if (channelUse)
             throw new Error('SessionManager: a request is already in flight; concurrent requests on one manager are not supported');
+        bindOrigin(input);
         runtime.lastUrl = input;
         runtime.lastHeaders = init?.headers;
         const previous = captureRuntimeStateSnapshot({
@@ -818,6 +862,7 @@ export function sessionManager(parameters) {
                 throw new Error('No WebSocket implementation available. Pass `webSocket` to sessionManager() in this runtime.');
             }
             const probeUrl = webSocketProbeUrl(input);
+            bindOrigin(probeUrl);
             const signalInit = init?.signal ? { signal: init.signal } : undefined;
             await bootstrapSession(probeUrl, signalInit);
             // Cold starts resume from `channelStore` after the probe's 402.
@@ -906,9 +951,15 @@ export function sessionManager(parameters) {
     };
     registerSessionManagerInternals(self, {
         consumeSseResponse(input, response, options) {
+            const origin = bindOrigin(input);
+            if (response.url && new URL(response.url).origin !== origin)
+                throw new Error('SessionManager: session response origin mismatch');
             return consumeSseSessionResponse(input, response, options, sseDriver);
         },
         rehydrate({ channel, challenge, input, spent }) {
+            const origin = bindOrigin(input);
+            if (channel.origin !== origin)
+                throw new Error('SessionManager: stored channel origin mismatch');
             if (!channel.opened)
                 throw new Error('Cannot restore a closed session channel.');
             if (!isTempoSessionChallenge(challenge)) {

package/dist/tempo/session/client/Transports.d.ts

@@ -201,6 +201,8 @@ export type TempoSessionChallenge = Challenge.Challenge<z.output<typeof Methods.
 export type CreateSessionCredential = (challenge: TempoSessionChallenge, context: SessionContext) => Promise<string>;
 /** Inputs for posting a precompile session top-up credential. */
 export type PostTopUpParameters = {
+    /** Request-local swap policy; undefined inherits the method default. */
+    autoSwap?: SessionContext['autoSwap'] | undefined;
     /** Additional deposit in raw token units. */
     additionalDeposit: bigint;
     /** Challenge used to authorize the management request. */
@@ -282,6 +284,8 @@ export declare function getSessionSnapshot(challenge: TempoSessionChallenge): Se
 /** Merges request headers and sets the challenge's credential header for a retry. */
 export declare function requestInitWithAuthorization(input: RequestInfo | URL, init: RequestInit | undefined, credential: string, challenge: TempoSessionChallenge): RequestInit;
 /** Returns the exact resource URL used for out-of-band management POSTs, without its fragment. */
+/** Returns whether a value is a `Request`, including one from another realm such as an iframe. */
+export declare function isRequest(value: unknown): value is Request;
 export declare function managementInput(input: RequestInfo | URL): RequestInfo | URL;
 /** Converts a WebSocket URL into the HTTP URL used for its payment challenge probe. */
 export declare function webSocketProbeUrl(input: string | URL): URL;