mppx 0.11.0 → 0.13.1

package/dist/tempo/server/Methods.js

@@ -1,3 +1,6 @@
+import * as Store from '../../Store.js';
+import * as Currencies from '../internal/currencies.js';
+import * as ChannelStore from '../session/server/ChannelStore.js';
 import { charge as sessionCharge_, session as session_, settle as settle_, settleBatch as settleBatch_, } from '../session/server/Session.js';
 import * as Ws_ from '../session/server/Ws.js';
 import { charge as charge_ } from './Charge.js';
@@ -11,18 +14,28 @@ function createChargeMethod(parameters) {
     // `tempo()` accepts the intersection of charge/session parameters, then
     // forwards only the fields each method understands. Preserve the inferred
     // parameter type so configured request defaults remain visible to handlers.
-    return tempo.charge(parameters);
+    return charge_(parameters);
 }
 function createSessionMethod(parameters) {
-    // Machine-token funding is configured at the Tempo family level, but only
-    // charge implements it today. Keep it out of session configuration until
-    // session routing has its own complete lifecycle support.
-    const { machineTokenEnabled: _machineTokenEnabled, ...sessionParameters } = parameters ?? {};
+    // These options apply only to charge, even when configured at the family level.
+    const { allowedFeeTokens: _allowedFeeTokens, machineTokenEnabled: _machineTokenEnabled, ...sessionParameters } = parameters ?? {};
     return sessionServer(sessionParameters);
 }
 /**
  * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
+ * Mainnet accepts OUSD first, then USDC.e. Testnet accepts OUSD first, then pathUSD.
+ * Use `currencies`
+ * for an ordered list of addresses/token definitions, including a one-element
+ * list for a single asset. Each currency creates charge and session offers; list
+ * order is presentation order, not a requirement on the client's choice.
+ * Chain-indexed definitions (including `tokens.tempo` from `viem/tokens`) are
+ * filtered to USD tokens deployed on `chainId`. Duplicates are removed by address.
+ * Explicit lists replace the defaults; an empty resolved list throws.
+ *
+ * The chain defaults to Tempo mainnet (Moderato with `testnet: true`). Set
+ * `chainId` explicitly when using a custom client for another network.
+ *
  * When configured, `relay` applies to the `charge` method. Session vouchers
  * remain local state transitions and session relay delegation will be added
  * with its action-specific lifecycle support.
@@ -32,22 +45,41 @@ function createSessionMethod(parameters) {
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
+ *   methods: [tempo.common({ recipient: '0x...' })],
  * })
  * ```
  */
 export function tempo(parameters) {
-    return [createChargeMethod(parameters), createSessionMethod(parameters)];
+    if (parameters?.currency !== undefined) {
+        if (parameters.currencies !== undefined)
+            throw new Error('Specify either `currency` or `currencies`, not both.');
+        return [createChargeMethod(parameters), createSessionMethod(parameters)];
+    }
+    const { currencies: _currencies, ...shared } = parameters ?? {};
+    const [first, ...rest] = Currencies.resolve(parameters ?? {});
+    const sessions = sessionOffers(parameters);
+    function createMethods(currency, index) {
+        const configured = { ...shared, ...currency };
+        return [createChargeMethod(configured), sessions[index]];
+    }
+    return [
+        ...createMethods(first, 0),
+        ...rest.flatMap((currency, index) => createMethods(currency, index + 1)),
+    ];
 }
 (function (tempo) {
-    /** Creates a Tempo `charge` method for one-time TIP-20 token transfers. */
-    tempo.charge = charge_;
+    /** Creates ordered Tempo charge offers: OUSD first, then the network fallback. */
+    tempo.charge = chargeOffers;
     /** Creates the common Tempo `charge` and `session` methods from shared parameters. */
     tempo.common = tempo;
-    /** Creates a TIP-1034 Tempo `session` method for session-based TIP-20 token payments. */
-    tempo.session = sessionServer;
-    /** Creates a Tempo `subscription` method for recurring TIP-20 token payments. */
-    tempo.subscription = subscription_;
+    /** Creates ordered TIP-1034 session offers with shared storage and settlement helpers. */
+    tempo.session = Object.assign(sessionOffers, {
+        charge: sessionCharge_,
+        settle: settle_,
+        settleBatch: settleBatch_,
+    });
+    /** Creates ordered subscription offers. Existing subscriptions retain their authorized currency. */
+    tempo.subscription = subscriptionOffers;
     /** Renews an overdue Tempo subscription outside of the HTTP request path. */
     tempo.renewSubscription = renewSubscription_;
     /** One-shot settle: reads highest voucher from storage and submits on-chain. */
@@ -57,4 +89,63 @@ export function tempo(parameters) {
     /** Experimental websocket helpers for Tempo sessions. */
     tempo.Ws = Ws_;
 })(tempo || (tempo = {}));
+/** Resolves the public factory configuration while preserving explicit legacy currencies. */
+function resolveCurrencies(parameters) {
+    if (parameters.currency !== undefined && parameters.currencies !== undefined)
+        throw new Error('Specify either `currency` or `currencies`, not both.');
+    return Currencies.resolve({
+        ...parameters,
+        ...(parameters.currency === undefined ? {} : { currencies: [parameters.currency] }),
+    });
+}
+/** Creates OUSD-first charge offers, with explicit currency lists replacing the defaults. */
+function chargeOffers(parameters) {
+    const { currencies: _currencies, ...shared } = parameters ?? {};
+    const [first, ...rest] = resolveCurrencies(parameters ?? {});
+    function create(currency) {
+        const configured = { ...shared, ...currency };
+        return charge_(configured);
+    }
+    return [create(first), ...rest.map(create)];
+}
+/** Creates OUSD-first session offers with shared storage and currency-aware settlement helpers. */
+function sessionOffers(parameters) {
+    const { currencies: _currencies, ...shared } = parameters ?? {};
+    const [first, ...rest] = resolveCurrencies(parameters ?? {});
+    const store = parameters?.store ?? Store.memory();
+    const settlements = new Map();
+    const key = (chainId, currency) => `${chainId}:${currency.toLowerCase()}`;
+    const settleScheduled = (channel) => {
+        const settle = settlements.get(key(channel.chainId, channel.token));
+        if (!settle)
+            throw new Error('Channel currency is not configured for this session handler.');
+        return settle(channel);
+    };
+    const extensions = {
+        settleScheduled,
+        serveWebSocket: (options) => Ws_.serve({
+            ...options,
+            store: ChannelStore.fromStore(store),
+            onChargeCommitted: settleScheduled,
+        }),
+    };
+    function create(currency) {
+        const configured = { ...shared, ...currency, store };
+        const method = session_(configured);
+        settlements.set(key(currency.chainId, currency.currency), method.extensions.settleScheduled);
+        return { ...method, extensions };
+    }
+    return [create(first), ...rest.map(create)];
+}
+/** Offers currencies for new subscriptions; stored subscriptions retain their authorized currency. */
+function subscriptionOffers(parameters) {
+    const { currencies: _currencies, ...shared } = parameters;
+    const [first, ...rest] = resolveCurrencies(parameters);
+    const store = parameters.store ?? Store.memory();
+    function create(currency) {
+        const configured = { ...shared, ...currency, store };
+        return subscription_(configured);
+    }
+    return [create(first), ...rest.map(create)];
+}
 //# sourceMappingURL=Methods.js.map

package/dist/tempo/server/Subscription.d.ts

@@ -68,7 +68,7 @@ export declare function subscription<const parameters extends subscription.Param
             amount: string;
             subscriptionExpires: string;
             methodDetails?: {
-                accessKey?: import("zod").output<import("zod/mini").ZodMiniObject<{
+                accessKey?: import("zod").infer<import("zod/mini").ZodMiniObject<{
                     accessKeyAddress: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
                     keyType: import("zod/mini").ZodMiniEnum<{
                         p256: "p256";

package/dist/tempo/server/Subscription.js

@@ -12,6 +12,7 @@ import * as Attribution from '../Attribution.js';
 import * as Account from '../internal/account.js';
 import * as defaults from '../internal/defaults.js';
 import * as FeePayer from '../internal/fee-payer.js';
+import { resolveFeeToken } from '../internal/fee-token.js';
 import * as Proof from '../internal/proof.js';
 import * as Methods from '../Methods.js';
 import { assertSubscriptionTiming, toSubscriptionPeriodSeconds, verifySubscriptionKeyAuthorization, } from '../subscription/KeyAuthorization.js';
@@ -246,6 +247,7 @@ export function subscription(p) {
                 });
             }
             if (activation.status === 'inFlight') {
+                await store.releaseCredential(credential.challenge.id);
                 throw new VerificationFailedError({
                     reason: 'subscription activation is already in flight',
                 });
@@ -283,8 +285,13 @@ export function subscription(p) {
                     if (!renewal) {
                         throw new VerificationFailedError({ reason: 'subscription renewal failed' });
                     }
-                    if (renewal.status === 'charged' || renewal.status === 'inFlight') {
+                    if (renewal.status === 'charged')
                         return renewal.receipt;
+                    if (renewal.status === 'inFlight') {
+                        await store.releaseCredential(credential.challenge.id);
+                        throw new VerificationFailedError({
+                            reason: 'subscription renewal is already in flight',
+                        });
                     }
                     await parameters.hooks?.renewed?.({
                         periodIndex,
@@ -306,6 +313,7 @@ export function subscription(p) {
 }
 // Access-key provisioning can cost around 4M gas.
 const defaultFeePayerPolicy = {
+    allowKeyAuthorization: true,
     maxGas: 5000000n,
     maxTotalFee: 200000000000000000n,
 };
@@ -688,6 +696,17 @@ async function submitSubscriptionPayment(parameters) {
             ...baseTransaction,
             nonceKey: 'expiring',
         });
+        const resolvedChainId = chainId ?? client.chain.id;
+        const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(resolvedChainId);
+        const feeToken = allowedFeeTokens.length === 1
+            ? allowedFeeTokens[0]
+            : await resolveFeeToken({
+                account: feePayer.address,
+                allowedTokens: allowedFeeTokens,
+                candidateTokens: allowedFeeTokens,
+                client,
+            });
+        delete prepared.feeToken;
         prepared.gas = (prepared.gas ?? 0n) + 5000n;
         prepared.feePayer = true;
         const userSerialized = await signTransaction(client, prepared);
@@ -698,16 +717,24 @@ async function submitSubscriptionPayment(parameters) {
             async complete() {
                 const sponsored = FeePayer.prepareSponsoredTransaction({
                     account: feePayer,
-                    chainId: chainId ?? client.chain.id,
+                    allowedFeeTokens,
+                    chainId: resolvedChainId,
                     details: {
                         amount: String(request.amount),
                         currency: String(request.currency),
                         recipient: String(request.recipient),
                     },
                     ...(feePayerPolicy ? { policy: feePayerPolicy } : {}),
-                    transaction: userTransaction,
+                    transaction: {
+                        ...userTransaction,
+                        ...(feeToken ? { feeToken } : {}),
+                    },
                 });
-                return { feePayer: feePayer.address, transaction: sponsored };
+                return {
+                    feePayer: feePayer.address,
+                    feeToken: sponsored.feeToken,
+                    transaction: sponsored,
+                };
             },
         });
         return await signTransaction(client, completed.transaction);