mppx 0.8.19 → 0.9.0

package/dist/tempo/server/Charge.js

@@ -1,5 +1,5 @@
 import * as SignatureEnvelope from 'ox/tempo/SignatureEnvelope';
-import { createClient, decodeFunctionData, formatUnits, http, keccak256, parseEventLogs, } from 'viem';
+import { decodeFunctionData, formatUnits, keccak256, parseEventLogs, } from 'viem';
 import { getTransactionReceipt, sendRawTransaction, sendRawTransactionSync, signTransaction, verifyTypedData, call as viem_call, } from 'viem/actions';
 import { Abis, Actions, Transaction } from 'viem/tempo';
 import { tempo as tempo_chain } from 'viem/tempo/chains';
@@ -15,7 +15,6 @@ import * as Charge_internal from '../internal/charge.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 MachineTokenCharge from '../internal/machine-token-charge.js';
 import * as Proof from '../internal/proof.js';
 import * as Selectors from '../internal/selectors.js';
 import * as Methods from '../Methods.js';
@@ -33,7 +32,7 @@ import * as SponsorBudget from './SponsorBudget.js';
  * ```
  */
 export function charge(parameters = {}) {
-    const { machineTokenEnabled, amount, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, memo, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, } = parameters;
+    const { amount, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, memo, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, } = parameters;
     const storeKeyPrefix = parameters.storeKeyPrefix ?? '';
     const rawStore = (parameters.store ?? Store.memory());
     const store = Store.from(rawStore, { keyPrefix: storeKeyPrefix });
@@ -59,12 +58,12 @@ export function charge(parameters = {}) {
             keyPrefix: storeKeyPrefix,
         })
         : undefined;
-    const { recipient, feePayer, feePayerUrl } = Account.resolve(parameters);
-    if (configuredFeeToken && feePayerUrl)
+    const { recipient, feePayer, remoteFeePayer } = Account.resolve(parameters);
+    if (configuredFeeToken && remoteFeePayer)
         throw new Error('`feeToken` can only be configured for a local fee payer.');
     const getClient = Client.getResolver({
         chain: { ...tempo_chain, experimental_preconfirmationTime: 500 },
-        feePayerUrl,
+        remoteFeePayer,
         getClient: parameters.getClient,
         rpcUrl: defaults.rpcUrl,
     });
@@ -85,17 +84,12 @@ export function charge(parameters = {}) {
         const currency = resolvedRequest.currency;
         const recipient = resolvedRequest.recipient;
         const memo = methodDetails?.memo;
-        const machineTokenEnabled = methodDetails?.machineTokenEnabled === true;
-        const settlementSender = machineTokenEnabled
-            ? MachineTokenCharge.getSettlementSender(chainId)
-            : undefined;
         const isZeroAmount = BigInt(amount) === 0n;
         Expires.assert(challenge.expires, challenge.id);
         if (isZeroAmount && payload.type !== 'proof')
             throw new MismatchError('Zero-amount challenges require a proof credential.', {});
         return {
             amount,
-            machineTokenEnabled,
             chainId,
             challenge,
             client: await getClient({ chainId }),
@@ -107,12 +101,11 @@ export function charge(parameters = {}) {
             recipient,
             requestAllowsFeePayer: request.feePayer !== false,
             resolvedRequest,
-            settlementSenders: settlementSender ? [settlementSender] : [],
             supportedModes,
         };
     }
     async function validateHashCredential(credential, payload, context) {
-        const { amount, chainId, challenge, client, currency, memo, methodDetails, recipient, settlementSenders, supportedModes, } = context;
+        const { amount, chainId, challenge, client, currency, memo, methodDetails, recipient, supportedModes, } = context;
         if (supportedModes && !supportedModes.includes('push'))
             throw new MismatchError('Hash credentials are not supported for this challenge.', {});
         const source = parseHashCredentialSource({
@@ -127,7 +120,6 @@ export function charge(parameters = {}) {
         const matchedLogs = await assertTransferLogs(receipt, {
             currency,
             sender,
-            settlementSenders,
             source,
             transfers,
             validateSender,
@@ -177,7 +169,7 @@ export function charge(parameters = {}) {
         return { sender: source.address };
     }
     async function validateTransactionCredential(credential, payload, request, context) {
-        const { machineTokenEnabled, amount, chainId, challenge, client, currency, memo, methodDetails, recipient, requestAllowsFeePayer, supportedModes, } = context;
+        const { amount, chainId, challenge, client, currency, memo, methodDetails, recipient, requestAllowsFeePayer, supportedModes, } = context;
         if (supportedModes && !supportedModes.includes('pull'))
             throw new MismatchError('Transaction credentials are not supported for this challenge.', {});
         const serializedTransaction = payload.signature;
@@ -188,42 +180,26 @@ export function charge(parameters = {}) {
             throw new MismatchError('Transaction must be signed by the sender before fee payer co-signing.', {});
         const isFeePayerTx = methodDetails?.feePayer === true &&
             requestAllowsFeePayer &&
-            !!(typeof request.feePayer === 'object' ? request.feePayer : feePayer || feePayerUrl);
+            !!(Account.is(request.feePayer) ? request.feePayer : feePayer || remoteFeePayer);
         const transfers = getExpectedTransfers({ amount, memo, methodDetails, recipient });
-        const machineTokenRoute = machineTokenEnabled
-            ? MachineTokenCharge.matchRoute({
-                calls: transaction.calls ?? [],
-                chainId: chainId ?? client.chain?.id,
-                currency,
-                transfers,
-            })
-            : undefined;
-        const matchedCalls = machineTokenRoute?.transfers ??
-            assertTransferCalls(transaction.calls ?? [], {
-                currency,
-                exactCount: isFeePayerTx,
-                transfers,
-            });
+        const matchedCalls = assertTransferCalls(transaction.calls ?? [], {
+            currency,
+            exactCount: isFeePayerTx,
+            transfers,
+        });
         if (!memo)
             assertChallengeBoundCallMemo(matchedCalls, {
                 challengeId: challenge.id,
                 realm: challenge.realm,
             });
         if (isFeePayerTx) {
-            if (!machineTokenRoute)
-                FeePayer.validateCalls(transaction.calls, { amount, currency, recipient }, { currency, expectedTransfers: transfers });
+            FeePayer.validateCalls(transaction.calls, { amount, currency, recipient }, { currency, expectedTransfers: transfers });
             FeePayer.assertAllowedFeeToken(transaction, FeePayer.defaultAllowedFeeTokens(chainId));
         }
         else {
             await viem_call(client, FeePayer.simulationTransaction(transaction, { feePayer: false }));
         }
-        return {
-            isFeePayerTx,
-            serializedTransaction,
-            settlementSenders: machineTokenRoute ? [machineTokenRoute.settlementSender] : [],
-            transaction,
-            transfers,
-        };
+        return { isFeePayerTx, serializedTransaction, transaction, transfers };
     }
     async function validateCredential(credential, request, context) {
         switch (context.payload.type) {
@@ -241,7 +217,7 @@ export function charge(parameters = {}) {
                 return { details: { mode: 'proof', sender }, type: 'proof' };
             }
             case 'transaction': {
-                const { isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers } = await validateTransactionCredential(credential, context.payload, request, context);
+                const { isFeePayerTx, serializedTransaction, transaction, transfers } = await validateTransactionCredential(credential, context.payload, request, context);
                 return {
                     details: {
                         mode: 'pull',
@@ -251,7 +227,6 @@ export function charge(parameters = {}) {
                     },
                     isFeePayerTx,
                     serializedTransaction,
-                    settlementSenders,
                     transaction,
                     transfers,
                     type: 'transaction',
@@ -263,7 +238,6 @@ export function charge(parameters = {}) {
         canOffer: parameters.canOffer,
         onPaymentSuccess: parameters.onPaymentSuccess,
         defaults: {
-            machineTokenEnabled,
             amount,
             currency,
             decimals,
@@ -324,22 +298,16 @@ export function charge(parameters = {}) {
             })();
             if (client.chain?.id !== chainId)
                 throw new Error(`Client not configured with chainId ${chainId}.`);
-            if (request.machineTokenEnabled && !MachineTokenCharge.isSupported(chainId))
-                throw new Error(`Machine tokens are not supported on chainId ${chainId}.`);
             const resolvedFeePayer = (() => {
                 if (request.feePayer === false)
                     return credential ? false : undefined;
-                const account = typeof request.feePayer === 'object' ? request.feePayer : feePayer;
-                const requested = account ?? feePayer ?? feePayerUrl;
+                const account = Account.is(request.feePayer) ? request.feePayer : feePayer;
                 if (credential)
-                    return account ?? (feePayerUrl ? true : undefined);
-                if (requested)
-                    return true;
-                return undefined;
+                    return account ?? (remoteFeePayer ? true : undefined);
+                return account || remoteFeePayer ? true : undefined;
             })();
             return {
                 ...request,
-                machineTokenEnabled: request.machineTokenEnabled || undefined,
                 chainId,
                 feePayer: resolvedFeePayer,
                 memo: request.memo || undefined,
@@ -363,7 +331,7 @@ export function charge(parameters = {}) {
             const { amount, chainId, challenge, client, currency, memo, methodDetails, recipient, requestAllowsFeePayer, } = context;
             const validated = await validateCredential(credential, request, context);
             const feePayerAccount = methodDetails?.feePayer === true && requestAllowsFeePayer
-                ? typeof request.feePayer === 'object'
+                ? Account.is(request.feePayer)
                     ? request.feePayer
                     : feePayer
                 : undefined;
@@ -394,7 +362,7 @@ export function charge(parameters = {}) {
                     };
                 }
                 case 'transaction': {
-                    const { isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers } = validated;
+                    const { isFeePayerTx, serializedTransaction, transaction, transfers } = validated;
                     // Pre-broadcast dedup: catch exact byte-for-byte replays early.
                     const hash = keccak256(serializedTransaction);
                     if (!(await tryClaimHash(store, hash, replayExpires))) {
@@ -406,9 +374,6 @@ export function charge(parameters = {}) {
                     let finalHash;
                     let reservation;
                     try {
-                        const broadcastClient = feePayerUrl && isFeePayerTx
-                            ? createClient({ chain: client.chain, transport: http(feePayerUrl) })
-                            : client;
                         const allowedFeeTokens = FeePayer.defaultAllowedFeeTokens(chainId);
                         if (isFeePayerTx)
                             FeePayer.assertAllowedFeeToken(transaction, allowedFeeTokens);
@@ -447,7 +412,7 @@ export function charge(parameters = {}) {
                                     sponsor: completed.feePayer,
                                 };
                             }
-                            if (feePayerUrl && isFeePayerTx) {
+                            if (remoteFeePayer && isFeePayerTx) {
                                 const completed = await FeePayer.preflightSponsorship({
                                     transaction,
                                     simulate: (request) => viem_call(client, request),
@@ -458,8 +423,8 @@ export function charge(parameters = {}) {
                                             chainId: chainId ?? client.chain.id,
                                             details: { amount, currency, recipient },
                                             policy: transactionFeePayerPolicy,
+                                            request: (args) => client.request(args),
                                             transaction,
-                                            url: feePayerUrl,
                                         });
                                         return { ...hosted, transaction };
                                     },
@@ -522,7 +487,7 @@ export function charge(parameters = {}) {
                             });
                         broadcastAttempted = true;
                         if (waitForConfirmation) {
-                            const receipt = await sendRawTransactionSync(broadcastClient, {
+                            const receipt = await sendRawTransactionSync(client, {
                                 serializedTransaction: serializedTransaction_final,
                             });
                             if (reservation)
@@ -530,7 +495,6 @@ export function charge(parameters = {}) {
                             const matchedLogs = await assertTransferLogs(receipt, {
                                 currency,
                                 sender: transaction.from,
-                                settlementSenders,
                                 transfers,
                             });
                             if (!memo)
@@ -547,7 +511,7 @@ export function charge(parameters = {}) {
                         // Optimistic path: broadcast without waiting for confirmation
                         // (simulation above already ran). The returned receipt assumes
                         // success — callers opt in via waitForConfirmation: false.
-                        const reference = await sendRawTransaction(broadcastClient, {
+                        const reference = await sendRawTransaction(client, {
                             serializedTransaction: serializedTransaction_final,
                         });
                         if (reference.toLowerCase() !== finalHash.toLowerCase())
@@ -586,11 +550,10 @@ function chargeBinding(request) {
     // Exhaustively destructure so new charge request fields require an explicit binding decision.
     const { amount, currency, description, externalId, methodDetails, recipient, ...requestRest } = request;
     requestRest;
-    const { chainId, feePayer, machineTokenEnabled, memo, splits, supportedModes, ...methodDetailsRest } = methodDetails ?? {};
+    const { chainId, feePayer, memo, splits, supportedModes, ...methodDetailsRest } = methodDetails ?? {};
     methodDetailsRest;
     void feePayer;
     return {
-        machineTokenEnabled,
         amount,
         chainId,
         currency,
@@ -732,9 +695,7 @@ async function assertTransferLogs(receipt, parameters) {
             if (!(await isValidTransferSender({
                 expectedSender: parameters.sender,
                 sender: log.args.from,
-                settlementSenders: parameters.settlementSenders,
                 source: parameters.source,
-                transactionSender: receipt.from,
                 validateSender: parameters.validateSender,
             })))
                 continue;
@@ -809,9 +770,6 @@ function isSameTransferLog(a, b) {
 async function isValidTransferSender(parameters) {
     if (TempoAddress.isEqual(parameters.sender, parameters.expectedSender))
         return true;
-    if (TempoAddress.isEqual(parameters.transactionSender, parameters.expectedSender) &&
-        parameters.settlementSenders?.some((sender) => TempoAddress.isEqual(parameters.sender, sender)))
-        return true;
     if (!parameters.validateSender)
         return false;
     return parameters.validateSender({

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

@@ -7,20 +7,16 @@ import { renew as renewSubscription_, subscription as subscription_ } from './Su
 /**
  * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
- * `machineTokenEnabled` lets compatible clients fund either method with the
- * first-party machine token while the merchant continues to request its payout
- * currency and recipient normally.
+ * 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.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: tempo({
- *     currency: '0x...',
- *     machineTokenEnabled: true,
- *     recipient: '0x...',
- *   }),
+ *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
  * })
  * ```
  */
@@ -41,7 +37,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
-            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             amount: import("zod/mini").ZodMiniString<string>;
             chainId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
             currency: import("zod/mini").ZodMiniString<string>;
@@ -67,7 +62,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             recipient?: string | undefined;
             amount: string;
             methodDetails?: {
-                machineTokenEnabled?: boolean | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
                 memo?: string | undefined;
@@ -79,7 +73,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
-            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -104,7 +97,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
         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>;
@@ -121,18 +113,15 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 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("../session/precompile/Protocol.js").ChannelDescriptor, import("../session/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("../session/precompile/Protocol.js").ChannelDescriptor, import("../session/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">;
         };
@@ -145,7 +134,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             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>>;
@@ -169,7 +157,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
                 feeToken?: string | undefined;
-                machineTokenEnabled?: boolean | undefined;
                 operator?: string | undefined;
                 sessionProtocol?: "v1" | "v2" | undefined;
                 sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
@@ -183,7 +170,6 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
             feeToken?: string | undefined;
-            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;

package/dist/tempo/server/Methods.js

@@ -20,20 +20,16 @@ function createSessionMethod(parameters) {
 /**
  * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
- * `machineTokenEnabled` lets compatible clients fund either method with the
- * first-party machine token while the merchant continues to request its payout
- * currency and recipient normally.
+ * 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.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: tempo({
- *     currency: '0x...',
- *     machineTokenEnabled: true,
- *     recipient: '0x...',
- *   }),
+ *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
  * })
  * ```
  */