mppx 0.14.1 → 0.16.0

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

@@ -377,6 +377,8 @@ export type SessionManagerRuntime = RuntimeState & {
     lastChallenge: TempoSessionChallenge | null;
     /** Last HTTP resource URL usable for management POSTs. */
     lastUrl: RequestInfo | URL | null;
+    /** Headers of the last HTTP request, whose application Authorization management POSTs keep. */
+    lastHeaders?: HeadersInit | undefined;
     /** Active WebSocket payment session bookkeeping, when a socket is open. */
     socketSession: ActiveSocketSession | null;
 };

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

@@ -323,7 +323,7 @@ export function session(parameters = {}) {
             },
         };
         return wrapSseResponse({
-            onNeedVoucher: (event, streamSignal) => handleSseNeedVoucher({ challenge, driver, input, signal: streamSignal }, event),
+            onNeedVoucher: (event, streamSignal) => handleSseNeedVoucher({ challenge, driver, headers, input, signal: streamSignal }, event),
             onReceipt() { },
             response,
             signal,

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

@@ -1,5 +1,6 @@
 import type { Hex } from 'ox';
 import { type Address } from 'viem';
+import * as ProofRealm from '../../../client/internal/ProofRealm.js';
 import * as Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
 import { type ChannelStore } from '../client/ChannelStore.js';
@@ -73,6 +74,11 @@ export declare namespace sessionManager {
         autoSwap?: sessionPlugin.Parameters['autoSwap'];
         /** 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,
+         * mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
+         */
+        trustedTempoProofRealms?: ProofRealm.TrustedRealms | 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`. */

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

@@ -4,6 +4,8 @@ import * as Challenge from '../../../Challenge.js';
 import * as Fetch from '../../../client/internal/Fetch.js';
 import * as MethodChallenge from '../../../client/internal/MethodChallenge.js';
 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 Account from '../../../viem/Account.js';
 import * as Client from '../../../viem/Client.js';
@@ -353,17 +355,19 @@ export function sessionManager(parameters) {
                 return undefined;
             if (!isZeroAmountChargeChallenge(challenge))
                 return undefined;
+            // The proof authenticates the payer at the challenge realm: sign only for the server it is
+            // sent to, and never after a redirect to another origin.
+            const target = new URL(String(bootstrapInput), typeof location !== 'undefined' ? location.href : undefined);
+            if (challengeResponse.url && new URL(challengeResponse.url).origin !== target.origin)
+                return undefined;
+            ProofRealm.assert(challenge, target, parameters.trustedTempoProofRealms);
             const credential = await chargeMethod.createCredential({
                 challenge: challenge,
                 context: {},
             });
-            const response = await config.fetch(bootstrapInput, {
-                ...headInit,
-                headers: {
-                    ...Fetch.normalizeHeaders(headInit.headers),
-                    [Constants.Headers.authorization]: credential,
-                },
-            });
+            const response = await config.fetch(bootstrapInput, 
+            // Runtimes do not strip custom payment headers on cross-origin redirects.
+            setCredentialHeader({ ...headInit, redirect: 'manual' }, Challenge.credentialHeader(challenge), credential));
             if (response.ok)
                 return await storeSnapshotHeader(response);
             return undefined;
@@ -643,6 +647,7 @@ export function sessionManager(parameters) {
         if (channelUse)
             throw new Error('SessionManager: a request is already in flight; concurrent requests on one manager are not supported');
         runtime.lastUrl = input;
+        runtime.lastHeaders = init?.headers;
         const previous = captureRuntimeStateSnapshot({
             channel: runtime.channel,
             spent: runtime.spent,
@@ -732,6 +737,7 @@ export function sessionManager(parameters) {
             createSessionCredential,
             fetch: config.fetch,
             getMinimumSpent: () => runtime.spent,
+            headers: runtime.lastHeaders,
             lastUrl: runtime.lastUrl,
             resolveSignedCloseAmount: (challenge) => getValidatedFallbackCloseAmount(target, challenge, true),
             signedCloseAmount: getValidatedFallbackCloseAmount(target),
@@ -799,6 +805,7 @@ export function sessionManager(parameters) {
                     additionalDeposit: target.additionalDeposit,
                     challenge: target.challenge,
                     channelId: target.channelId,
+                    headers: runtime.lastHeaders,
                     input: target.input,
                 });
             });

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

@@ -78,6 +78,8 @@ export type TopUpRequirement = {
     deposit: bigint;
     /** Original paid resource URL; converted to a management URL by the caller. */
     input: RequestInfo | URL;
+    /** Headers of the paid request; management posts keep its application `Authorization`. */
+    headers?: HeadersInit | undefined;
     /** Minimum cumulative voucher amount the server needs. */
     requiredCumulative: bigint;
     /** Cancels nested management requests for this top-up. */
@@ -158,6 +160,8 @@ export type ResolveNeedVoucherContextParameters = {
     getChannel(): ChannelEntry | null;
     /** Original paid resource URL; converted to management URL by the caller. */
     input: RequestInfo | URL;
+    /** Headers of the paid request; management posts keep its application `Authorization`. */
+    headers?: HeadersInit | undefined;
     /** Cancels top-up work triggered by this event. */
     signal?: AbortSignal | undefined;
     /** Performs the deposit top-up when server-required cumulative exceeds deposit. */
@@ -211,6 +215,8 @@ export type PostTopUpParameters = {
     fetch: typeof globalThis.fetch;
     /** Original paid resource URL; normalized to a management URL before posting. */
     input: RequestInfo | URL;
+    /** Headers of the paid request; management posts keep its application `Authorization`. */
+    headers?: HeadersInit | undefined;
     /** Cancels the top-up management request. */
     signal?: AbortSignal | undefined;
     /** Persists an unresolved funding outcome before another caller can reuse the channel. */
@@ -254,6 +260,8 @@ export type CloseHttpSessionParameters = {
     fetch: typeof globalThis.fetch;
     /** Last paid resource URL; used as the management endpoint base. */
     lastUrl: RequestInfo | URL | null;
+    /** Headers of the last paid request; the close post keeps its application `Authorization`. */
+    headers?: HeadersInit | undefined;
     /** Returns the latest cumulative spend already confirmed by the client. */
     getMinimumSpent?: (() => bigint) | undefined;
     /** Resolves the close amount again when the server refreshes the challenge. */
@@ -271,8 +279,8 @@ export declare function isTempoSessionChallenge(challenge: Challenge.Challenge):
 export declare function isTip1034SessionChallenge(challenge: Challenge.Challenge): challenge is TempoSessionChallenge;
 /** Reads a server-provided session snapshot from challenge method details. */
 export declare function getSessionSnapshot(challenge: TempoSessionChallenge): SessionSnapshot | undefined;
-/** Merges request headers and sets the payment authorization header for a retry. */
-export declare function requestInitWithAuthorization(input: RequestInfo | URL, init: RequestInit | undefined, credential: string): RequestInit;
+/** 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. */
 export declare function managementInput(input: RequestInfo | URL): RequestInfo | URL;
 /** Converts a WebSocket URL into the HTTP URL used for its payment challenge probe. */
@@ -335,7 +343,7 @@ export type SsePaymentDriver = Pick<OpenSseSessionParameters, 'assertVoucherWith
  */
 export declare function openSseSession(input: RequestInfo | URL, init: SseDriverOptions | undefined, driver: OpenSseSessionParameters): Promise<AsyncIterable<string>>;
 /** @internal Consumes an already-paid SSE response with the session transport driver. */
-export declare function consumeSseSessionResponse(input: RequestInfo | URL, response: Response, options: SseResponseOptions | undefined, driver: OpenSseSessionParameters): AsyncIterable<string>;
+export declare function consumeSseSessionResponse(input: RequestInfo | URL, response: Response, options: SseResponseOptions | undefined, driver: OpenSseSessionParameters, headers?: HeadersInit | undefined): AsyncIterable<string>;
 /** Application SSE frame emitted after session payment events are handled. */
 export type SseResponseFrame = {
     /** Parsed application data, when present. */
@@ -362,6 +370,7 @@ export declare function wrapSseResponse(parameters: DriveSseResponseParameters):
 export declare function handleSseNeedVoucher(parameters: {
     challenge: TempoSessionChallenge | null;
     driver: SsePaymentDriver;
+    headers?: HeadersInit | undefined;
     input: RequestInfo | URL;
     signal?: AbortSignal | undefined;
 }, event: NeedVoucherEvent): Promise<void>;

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

@@ -1,6 +1,7 @@
 import { Hex } from 'ox';
 import * as Challenge from '../../../Challenge.js';
 import * as Fetch from '../../../client/internal/Fetch.js';
+import { setCredentialHeader } from '../../../client/internal/protocols/Shared.js';
 import * as Constants from '../../../Constants.js';
 import * as PaymentCredential from '../../../Credential.js';
 import { deserializeSessionReceipt, isEventStream, parseEvent, readSessionChallengeAmount, uint96, } from '../precompile/Protocol.js';
@@ -211,6 +212,7 @@ export async function resolveNeedVoucherContext(parameters) {
     await parameters.topUpIfNeeded({
         challenge: parameters.challenge,
         input: parameters.input,
+        headers: parameters.headers,
         channelId: parameters.expectedChannelId,
         deposit: eventAmounts.deposit,
         requiredCumulative: eventAmounts.requiredCumulative,
@@ -246,17 +248,18 @@ export function isTip1034SessionChallenge(challenge) {
 export function getSessionSnapshot(challenge) {
     return Constants.getMethodDetail(challenge.request.methodDetails, Constants.MethodDetailKeys.sessionSnapshot);
 }
-/** Merges request headers and sets the payment authorization header for a retry. */
-export function requestInitWithAuthorization(input, init, credential) {
+/** Merges request headers and sets the challenge's credential header for a retry. */
+export function requestInitWithAuthorization(input, init, credential, challenge) {
     const requestHeaders = input instanceof Request ? input.headers : undefined;
-    return {
+    return setCredentialHeader({
         ...init,
+        // Runtimes do not strip custom payment headers on cross-origin redirects.
+        redirect: 'manual',
         headers: {
             ...Fetch.normalizeHeaders(requestHeaders),
             ...Fetch.normalizeHeaders(init?.headers),
-            [Constants.Headers.authorization]: credential,
         },
-    };
+    }, Challenge.credentialHeader(challenge), credential);
 }
 /** Returns the exact resource URL used for out-of-band management POSTs, without its fragment. */
 export function managementInput(input) {
@@ -324,6 +327,7 @@ export async function postTopUp(parameters) {
         },
         createSessionCredential: parameters.createSessionCredential,
         fetch: parameters.fetch,
+        headers: parameters.headers,
         input: parameters.input,
         signal: parameters.signal,
     }).catch(async (error) => {
@@ -360,7 +364,8 @@ async function postManagementCredential(parameters) {
                 parameters.fetch(managementInput(parameters.input), {
                     method: 'POST',
                     signal: controller.signal,
-                    headers: { [Constants.Headers.authorization]: authorization },
+                    redirect: 'manual',
+                    headers: managementHeaders(challenge, authorization, parameters.input, parameters.headers),
                 }),
                 aborted,
             ]);
@@ -397,6 +402,7 @@ export async function retryHttpPaymentRequired(parameters) {
     await parameters.topUpIfNeeded({
         challenge,
         input: parameters.input,
+        headers: parameters.init?.headers,
         channelId: snapshot.channelId,
         deposit: BigInt(snapshot.deposit),
         requiredCumulative,
@@ -419,7 +425,7 @@ export async function retryHttpPaymentRequired(parameters) {
             descriptor: currentChannel.descriptor,
             cumulativeAmountRaw: cumulativeAmount.toString(),
         });
-        retry = await parameters.fetch(parameters.input, requestInitWithAuthorization(parameters.input, parameters.init, credential));
+        retry = await parameters.fetch(parameters.input, requestInitWithAuthorization(parameters.input, parameters.init, credential, challenge));
     }
     catch (error) {
         await restore();
@@ -463,7 +469,8 @@ export async function closeHttpSession(parameters) {
         });
         return parameters.fetch(parameters.lastUrl, {
             method: 'POST',
-            headers: { [Constants.Headers.authorization]: credential },
+            redirect: 'manual',
+            headers: managementHeaders(challenge, credential, parameters.lastUrl, parameters.headers),
         });
     };
     let response = await postClose(parameters.target.challenge);
@@ -516,17 +523,17 @@ export async function openSseSession(input, init, driver) {
     let response = await driver.doFetch(input, sseInit);
     if (!isEventStream(response) && driver.getChannel()?.opened)
         response = await driver.doFetch(input, sseInit);
-    return consumeSseSessionResponse(input, response, { onReceipt, signal }, driver);
+    return consumeSseSessionResponse(input, response, { onReceipt, signal }, driver, sseInit.headers);
 }
 /** @internal Consumes an already-paid SSE response with the session transport driver. */
-export function consumeSseSessionResponse(input, response, options, driver) {
+export function consumeSseSessionResponse(input, response, options, driver, headers) {
     if (!isEventStream(response))
         throw new Error('SSE response is not an event stream.');
     if (!response.body)
         throw new Error('Response has no body.');
     const challenge = driver.getChallenge();
     return iterateSseMessages({
-        onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, input, signal: options?.signal }, event),
+        onNeedVoucher: (event) => handleSseNeedVoucher({ challenge, driver, headers, input, signal: options?.signal }, event),
         onReceipt(receipt) {
             driver.acceptReceipt(receipt);
             options?.onReceipt?.(receipt);
@@ -682,6 +689,7 @@ export async function handleSseNeedVoucher(parameters, event) {
         event,
         expectedChannelId: channel.channelId,
         getChannel: parameters.driver.getChannel,
+        headers: parameters.headers,
         input: parameters.input,
         signal: parameters.signal,
         topUpIfNeeded: parameters.driver.topUpIfNeeded,
@@ -693,6 +701,7 @@ export async function handleSseNeedVoucher(parameters, event) {
         context: resolution.context,
         createSessionCredential: parameters.driver.createSessionCredential,
         fetch: parameters.driver.fetch,
+        headers: parameters.headers,
         input: parameters.input,
         signal: parameters.signal,
     });
@@ -979,4 +988,21 @@ function handleReceipt(parameters, receipt) {
     parameters.driver.options?.onReceipt?.(receipt);
     parameters.driver.settleReceipt(receipt);
 }
+/**
+ * Builds the headers of a management or close post: the session credential in the header the
+ * challenge selects, plus the paid request's application `Authorization` when the credential
+ * goes elsewhere (`requiresAuth`), so the post passes the same application authentication.
+ */
+function managementHeaders(challenge, credential, input, headers) {
+    const header = Challenge.credentialHeader(challenge);
+    const result = new Headers();
+    if (header.toLowerCase() !== Constants.Headers.authorization.toLowerCase()) {
+        const authorization = new Headers(headers).get(Constants.Headers.authorization) ??
+            (input instanceof Request ? input.headers.get(Constants.Headers.authorization) : null);
+        if (authorization && !authorization.startsWith(`${Constants.Schemes.payment} `))
+            result.set(Constants.Headers.authorization, authorization);
+    }
+    result.set(header, credential);
+    return result;
+}
 //# sourceMappingURL=Transports.js.map

package/dist/tempo/session/precompile/Chain.js

@@ -300,9 +300,6 @@ function validateCredentialSponsorship(parameters) {
         return;
     if (feePayer === true) {
         assertPrecompileFeePayerPolicy({ prepared: transaction, policy: feePayerPolicy });
-        if (feePayerPolicy?.allowKeyAuthorization === false &&
-            transaction.keyAuthorization !== undefined)
-            throw new BadRequestError({ reason: 'fee-payer policy keyAuthorization is not allowed' });
         FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens);
         FeePayer.assertTransactionPolicy({
             challengeExpires,

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

@@ -1,3 +1,4 @@
+import type * as Challenge from '../../../Challenge.js';
 import { type SessionCredentialContext } from '../precompile/Protocol.js';
 import * as ChannelStore from './ChannelStore.js';
 import type { MeteredStreamOptions, SessionController } from './MeteredStream.js';
@@ -13,6 +14,7 @@ export type SessionRouteResult = {
     challenge: Response;
 } | {
     status: 200;
+    challenge?: Challenge.Challenge | undefined;
     withReceipt(response?: Response): Response | Promise<Response>;
 };
 /** HTTP route used to perform a WebSocket payment probe. */
@@ -36,14 +38,15 @@ export declare function serve(options: serve.Options): Promise<void>;
 /** Type helpers for {@link serve}. */
 export declare namespace serve {
     type Options = {
-        /** Expected per-tick amount in raw units. When set, credentials whose
+        /** Expected per-tick amount in raw units. Required for custom routes that
+         *  do not return their canonical challenge. When set, credentials whose
          *  challenge `request.amount` does not match are rejected. Use this to
          *  pin the price when the route is backed by `Mppx.compose()` with
          *  multiple offers — otherwise a client can select the cheapest offer
          *  and still receive the same stream. */
         amount?: string | undefined;
         /** Application stream. A manual stream can call `charge(amount)` with a
-         *  per-message raw-unit amount; omitting it uses the challenge tick cost. */
+         *  per-message raw-unit amount; omitting it uses the canonical route tick cost. */
         generate: AsyncIterable<string> | ((stream: SessionController) => AsyncIterable<string>);
         /** Maximum accepted inbound WebSocket frame size in bytes. @default 65536 */
         maxIncomingMessageBytes?: number | undefined;

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

@@ -133,6 +133,11 @@ export async function serve(options) {
             return;
         }
         const { receipt } = authorizationResult;
+        const tickCost = expectedAmount !== undefined ? BigInt(expectedAmount) : authorizationResult.amount;
+        if (tickCost === undefined) {
+            await close(1008, 'WebSocket route must provide canonical pricing or an explicit amount');
+            return;
+        }
         if (payload.action === 'voucher' && runtime.streamContext) {
             runtime.streamContext.challengeId = credential.challenge.id;
         }
@@ -149,7 +154,7 @@ export async function serve(options) {
         runtime.streamContext = {
             challengeId: credential.challenge.id,
             channelId: payload.channelId,
-            tickCost: readSessionChallengeAmount(credential.challenge),
+            tickCost,
         };
         // Defer the first application frame until after the client receives the
         // auth receipt and has a chance to install its own message listeners.
@@ -299,6 +304,10 @@ async function authorizePaymentFrame(parameters) {
     const receiptHeader = response.headers.get(Constants.Headers.paymentReceipt);
     if (!receiptHeader)
         throw new Error('management response missing Payment-Receipt header');
-    return { status: 'accepted', receipt: deserializeSessionReceipt(receiptHeader) };
+    return {
+        status: 'accepted',
+        amount: result.challenge ? readSessionChallengeAmount(result.challenge) : undefined,
+        receipt: deserializeSessionReceipt(receiptHeader),
+    };
 }
 //# sourceMappingURL=Ws.js.map

package/dist/tempo/subscription/Store.d.ts

@@ -13,9 +13,13 @@ export type SubscriptionStore = {
     /** Looks up a generated access key for a resolved request key. */
     getAccessKey(key: string): Promise<SubscriptionAccessKeyRecord | null>;
     /** Looks up a generated access key by its public access key address. */
-    getAccessKeyByAddress(address: string): Promise<SubscriptionAccessKeyRecord | null>;
+    getAccessKeyByAddress(address: string, keyToken?: `0x${string}`): Promise<SubscriptionAccessKeyRecord | null>;
     /** Looks up the active subscription for a resolved request key. */
     getByKey(key: string): Promise<SubscriptionRecord | null>;
+    /** Creates a key sealed in a client-carried token, without retaining per-challenge state. */
+    createChallengeAccessKey(): Promise<SubscriptionAccessKeyRecord>;
+    /** Retains a key after verified payment submission for subsequent subscription billing. */
+    retainAccessKey(key: string, record: SubscriptionAccessKeyRecord): Promise<void>;
     /** Gets or creates the server-owned access key for a resolved request key. */
     getOrCreateAccessKey(key: string): Promise<SubscriptionAccessKeyRecord>;
     /** Upserts a subscription record and marks it as active for its lookup key. */
@@ -85,6 +89,8 @@ export declare namespace fromStore {
     type Options = {
         /** Key prefix for server-owned subscription access keys. @default `'tempo:subscription:access-key:'` */
         accessKeyPrefix?: string | undefined;
+        /** Namespace for the persistent anonymous-challenge sealing key. */
+        pendingAccessKeyPrefix?: string | undefined;
         /** Key prefix for resolved subscription activation locks. @default `'tempo:subscription:activation:'` */
         activationPrefix?: string | undefined;
         /** Milliseconds before a stuck activation lock can be replaced. @default `900000` */

package/dist/tempo/subscription/Store.js

@@ -1,15 +1,16 @@
-import { Secp256k1 } from 'ox';
+import { Hex, Secp256k1 } from 'ox';
 import { Account as TempoAccount } from 'viem/tempo';
 const defaultRecordPrefix = 'tempo:subscription:record:';
 const defaultKeyPrefix = 'tempo:subscription:key:';
 const defaultActivationPrefix = 'tempo:subscription:activation:';
 const defaultAccessKeyPrefix = 'tempo:subscription:access-key:';
+const defaultPendingAccessKeyPrefix = 'tempo:subscription:pending-access-key:';
 const defaultCredentialPrefix = 'tempo:subscription:credential:';
 const defaultActivationTimeoutMs = 15 * 60 * 1_000;
 const defaultRenewalTimeoutMs = 15 * 60 * 1_000;
 /** Wraps a generic key-value {@link Store.Store} with subscription-specific accessors. */
 export function fromStore(store, options) {
-    const { accessKeyPrefix = defaultAccessKeyPrefix, activationPrefix = defaultActivationPrefix, activationTimeoutMs = defaultActivationTimeoutMs, credentialPrefix = defaultCredentialPrefix, keyPrefix = defaultKeyPrefix, recordPrefix = defaultRecordPrefix, renewalTimeoutMs = defaultRenewalTimeoutMs, } = options ?? {};
+    const { accessKeyPrefix = defaultAccessKeyPrefix, activationPrefix = defaultActivationPrefix, activationTimeoutMs = defaultActivationTimeoutMs, credentialPrefix = defaultCredentialPrefix, keyPrefix = defaultKeyPrefix, recordPrefix = defaultRecordPrefix, pendingAccessKeyPrefix = defaultPendingAccessKeyPrefix, renewalTimeoutMs = defaultRenewalTimeoutMs, } = options ?? {};
     function recordKey(subscriptionId) {
         return `${recordPrefix}${subscriptionId}`;
     }
@@ -34,6 +35,14 @@ export function fromStore(store, options) {
             return null;
         return (await store.get(recordKey(subscriptionId)));
     }
+    async function ensureAccessKeyAddressIndex(record) {
+        await store.update(accessKeyAddressKey(record.accessKeyAddress), (current) => {
+            if (current)
+                return { op: 'noop', result: undefined };
+            return { op: 'set', value: record, result: undefined };
+        });
+        return record;
+    }
     async function clearRenewalState(subscriptionId, periodIndex, attempt) {
         await store.update(recordKey(subscriptionId), (current) => {
             const subscription = current;
@@ -61,7 +70,35 @@ export function fromStore(store, options) {
         const marker = (await store.get(activationKey(lookupKey)));
         return marker?.challengeId === challengeId;
     }
+    const sealingKey = `${pendingAccessKeyPrefix}sealing-key`;
+    // One shared secret survives across workers; anonymous issuance never grows the store.
+    async function getSealingKey() {
+        const candidate = Hex.fromBytes(crypto.getRandomValues(new Uint8Array(32)));
+        const secret = await store.update(sealingKey, (current) => current
+            ? { op: 'noop', result: current }
+            : { op: 'set', value: candidate, result: candidate });
+        return crypto.subtle.importKey('raw', new Uint8Array(Hex.toBytes(secret)), 'AES-GCM', false, [
+            'encrypt',
+            'decrypt',
+        ]);
+    }
     return {
+        async createChallengeAccessKey() {
+            const privateKey = Secp256k1.randomPrivateKey();
+            const account = TempoAccount.fromSecp256k1(privateKey);
+            const iv = crypto.getRandomValues(new Uint8Array(12));
+            const sealed = new Uint8Array(await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, await getSealingKey(), new Uint8Array(Hex.toBytes(privateKey))));
+            return {
+                accessKeyAddress: account.address.toLowerCase(),
+                keyType: account.keyType,
+                privateKey,
+                keyToken: Hex.fromBytes(new Uint8Array([...iv, ...sealed])),
+            };
+        },
+        async retainAccessKey(key, record) {
+            await store.put(accessKeyKey(key), record);
+            await store.put(accessKeyAddressKey(record.accessKeyAddress), record);
+        },
         async activate({ challengeId, create, isReusable, lookupKey }) {
             const claimed = await store.update(credentialKey(challengeId), (current) => {
                 if (current)
@@ -155,8 +192,31 @@ export function fromStore(store, options) {
         async getAccessKey(key) {
             return (await store.get(accessKeyKey(key)));
         },
-        async getAccessKeyByAddress(address) {
-            return (await store.get(accessKeyAddressKey(address)));
+        async getAccessKeyByAddress(address, keyToken) {
+            const stored = (await store.get(accessKeyAddressKey(address)));
+            if (stored)
+                return stored;
+            if (!keyToken)
+                return null;
+            try {
+                const bytes = Hex.toBytes(keyToken);
+                // 12-byte nonce, 32-byte private key, and 16-byte authentication tag.
+                if (bytes.length !== 60)
+                    return null;
+                const privateKey = Hex.fromBytes(new Uint8Array(await crypto.subtle.decrypt({ name: 'AES-GCM', iv: bytes.slice(0, 12) }, await getSealingKey(), bytes.slice(12))));
+                const account = TempoAccount.fromSecp256k1(privateKey);
+                if (account.address.toLowerCase() !== address.toLowerCase())
+                    return null;
+                return {
+                    accessKeyAddress: account.address.toLowerCase(),
+                    keyType: account.keyType,
+                    privateKey,
+                    keyToken,
+                };
+            }
+            catch {
+                return null;
+            }
         },
         async getByKey(key) {
             return getByLookupKey(key);
@@ -164,7 +224,7 @@ export function fromStore(store, options) {
         async getOrCreateAccessKey(key) {
             const existing = (await store.get(accessKeyKey(key)));
             if (existing)
-                return existing;
+                return ensureAccessKeyAddressIndex(existing);
             const privateKey = Secp256k1.randomPrivateKey();
             const account = TempoAccount.fromSecp256k1(privateKey);
             const candidate = {
@@ -179,14 +239,7 @@ export function fromStore(store, options) {
                 }
                 return { op: 'set', value: candidate, result: candidate };
             })
-                .then(async (record) => {
-                await store.update(accessKeyAddressKey(record.accessKeyAddress), (current) => {
-                    if (current)
-                        return { op: 'noop', result: undefined };
-                    return { op: 'set', value: record, result: undefined };
-                });
-                return record;
-            });
+                .then(ensureAccessKeyAddressIndex);
         },
         async put(record) {
             await store.put(recordKey(record.subscriptionId), record);

package/dist/tempo/subscription/Types.d.ts

@@ -5,6 +5,8 @@ export type SubscriptionPeriodUnit = 'dev_second' | 'day' | 'week';
 export type SubscriptionAccessKey = {
     accessKeyAddress: Address;
     keyType: 'p256' | 'secp256k1' | 'webAuthn';
+    /** Opaque server-sealed key for stateless anonymous setup. */
+    keyToken?: `0x${string}` | undefined;
 };
 /** Server-owned subscription access key persisted for automatic billing. */
 export type SubscriptionAccessKeyRecord = SubscriptionAccessKey & {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.14.1",
+  "version": "0.16.0",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",
@@ -35,9 +35,9 @@
       "types": "./dist/client/node.d.ts",
       "default": "./dist/client/node.js"
     },
-    "./attestation": {
-      "types": "./dist/attestation/index.d.ts",
-      "default": "./dist/attestation/index.js"
+    "./identity": {
+      "types": "./dist/identity/index.d.ts",
+      "default": "./dist/identity/index.js"
     },
     "./discovery": {
       "types": "./dist/discovery/index.d.ts",
@@ -123,13 +123,17 @@
       "types": "./dist/tempo/index.d.ts",
       "default": "./dist/tempo/index.js"
     },
-    "./attestation/tap": {
-      "types": "./dist/tap/index.d.ts",
-      "default": "./dist/tap/index.js"
+    "./extensions/identity": {
+      "types": "./dist/extensions/identity/index.d.ts",
+      "default": "./dist/extensions/identity/index.js"
     },
-    "./attestation/web-bot-auth": {
-      "types": "./dist/web-bot-auth/index.d.ts",
-      "default": "./dist/web-bot-auth/index.js"
+    "./extensions/identity/tap": {
+      "types": "./dist/extensions/identity/tap/index.d.ts",
+      "default": "./dist/extensions/identity/tap/index.js"
+    },
+    "./extensions/identity/web-bot-auth": {
+      "types": "./dist/extensions/identity/web-bot-auth/index.d.ts",
+      "default": "./dist/extensions/identity/web-bot-auth/index.js"
     },
     "./html": {
       "types": "./dist/Html.d.ts",
@@ -206,7 +210,7 @@
     "eventsource-parser": "4.1.1",
     "ox": "0.14.45",
     "structured-headers": "2.1.0",
-    "zod": "^4.6.5"
+    "zod": "^4.6.7"
   },
   "repository": {
     "type": "git",

package/dist/attestation/Client.d.ts

@@ -1,17 +0,0 @@
-import type * as Types from './Types.js';
-/**
- * Combines request signers using one shared context per call.
- *
- * The returned signer creates a fresh context unless its caller supplies one,
- * allowing every signature on one HTTP attempt to share a nonce and timestamp.
- */
-export declare function composeSigners(...signers: readonly [Types.Signer, ...Types.Signer[]]): Types.Signer<'composed'>;
-/**
- * Wraps a fetch implementation so every outbound request is attested.
- *
- * Configure this wrapper as the underlying `fetch` passed to `mppx/client`
- * `Fetch.from()`. MPPX then uses it for both the initial request and its
- * automatic request containing an `Authorization: Payment` credential.
- */
-export declare function wrapFetch(fetch: typeof globalThis.fetch, signer: Types.Signer): typeof globalThis.fetch;
-//# sourceMappingURL=Client.d.ts.map

package/dist/attestation/Client.js

@@ -1,28 +0,0 @@
-import * as SigningContext from './internal/SigningContext.js';
-/**
- * Combines request signers using one shared context per call.
- *
- * The returned signer creates a fresh context unless its caller supplies one,
- * allowing every signature on one HTTP attempt to share a nonce and timestamp.
- */
-export function composeSigners(...signers) {
-    return {
-        protocol: 'composed',
-        async sign(request, context = SigningContext.create()) {
-            for (const signer of signers)
-                request = await signer.sign(request, context);
-            return request;
-        },
-    };
-}
-/**
- * Wraps a fetch implementation so every outbound request is attested.
- *
- * Configure this wrapper as the underlying `fetch` passed to `mppx/client`
- * `Fetch.from()`. MPPX then uses it for both the initial request and its
- * automatic request containing an `Authorization: Payment` credential.
- */
-export function wrapFetch(fetch, signer) {
-    return async (input, init) => fetch(await signer.sign(new Request(input, init)));
-}
-//# sourceMappingURL=Client.js.map

package/dist/attestation/Server.d.ts

@@ -1,4 +0,0 @@
-import type * as Types from './Types.js';
-/** Verifies every configured request-attestation protocol. */
-export declare function verify<const verifiers extends Types.VerifierMap>(request: Request, verifiers: verifiers): Promise<Types.VerificationsFrom<verifiers>>;
-//# sourceMappingURL=Server.d.ts.map