mppx 0.10.0 → 0.11.0

package/dist/client/Mppx.d.ts

@@ -24,18 +24,23 @@ export type PreparedPayment<methods extends readonly Method.AnyClient[] = readon
     /** Attaches a credential using the protocol that produced the selected challenge. */
     setCredential: (request: Transport.RequestOf<transport>, credential: string) => Transport.RequestOf<transport>;
 }>;
-/** A payment challenge prepared together with the exact HTTP request that produced it. */
-export type PreparedRequest<methods extends readonly Method.AnyClient[]> = Readonly<PreparedPayment<methods, Transport.Transport<RequestInit, Response>> & {
-    /** Exact request that returned the selected payment challenge. */
+/** An HTTP request prepared together with its response and optional payment. */
+export type PreparedRequest<methods extends readonly Method.AnyClient[], requirePayment extends boolean = false> = Readonly<{
+    /** Exact request that produced {@link response}. */
     request: Request;
-    /** Payment-required response returned for {@link request}. */
+    /** Response returned for {@link request}. */
     response: Response;
-    /** Redirects followed before receiving the payment challenge. */
+    /** Redirects followed before receiving {@link response}. */
     redirects: readonly PreparedRequest.Redirect[];
-    /** Creates and sends a credential to the prepared request without following redirects. */
-    pay: (context?: AnyContextFor<methods> | undefined) => Promise<Response>;
+    /** Selected payment when the response requires payment. */
+    payment: requirePayment extends true ? PreparedRequest.Payment<methods> : PreparedRequest.Payment<methods> | undefined;
 }>;
 export declare namespace PreparedRequest {
+    /** A request-bound payment that can be inspected or paid. */
+    type Payment<methods extends readonly Method.AnyClient[]> = Readonly<PreparedPayment<methods, Transport.Transport<RequestInit, Response>> & {
+        /** Creates and sends a credential to the prepared request without following redirects. */
+        pay: (context?: AnyContextFor<methods> | undefined) => Promise<Response>;
+    }>;
     /** A redirect followed while discovering a payment challenge. */
     type Redirect = Readonly<{
         from: string;
@@ -70,11 +75,17 @@ export type Mppx<methods extends Methods = Methods, transport extends Transport.
      */
     preparePayment: (response: Transport.ResponseOf<transport>, options?: preparePayment.Options<FlattenMethods<methods>, transport> | undefined) => Promise<PreparedPayment<FlattenMethods<methods>, transport>>;
     /**
-     * Follows safe pre-payment redirects and prepares the challenge with the exact request that
-     * produced it. Credential-bearing requests never follow redirects. Requires a runtime that
-     * exposes manual redirect responses; browsers return opaque redirects and are not supported.
+     * Follows safe pre-payment redirects and returns the response with its exact request. When the
+     * response requires payment, prepares its selected challenge without creating a credential.
+     * Credential-bearing requests never follow redirects. Requires a runtime that exposes manual
+     * redirect responses; browsers return opaque redirects and are not supported.
      */
-    prepareRequest: transport extends Transport.Transport<RequestInit, Response> ? (input: RequestInfo | URL, init?: RequestInit | undefined, options?: prepareRequest.Options<FlattenMethods<methods>> | undefined) => Promise<PreparedRequest<FlattenMethods<methods>>> : never;
+    prepareRequest: transport extends Transport.Transport<RequestInit, Response> ? {
+        <const requirePayment extends boolean>(input: RequestInfo | URL, init: RequestInit | undefined, options: prepareRequest.Options<FlattenMethods<methods>, requirePayment> & {
+            requirePayment: requirePayment;
+        }): Promise<PreparedRequest<FlattenMethods<methods>, requirePayment>>;
+        (input: RequestInfo | URL, init?: RequestInit | undefined, options?: prepareRequest.Options<FlattenMethods<methods>> | undefined): Promise<PreparedRequest<FlattenMethods<methods>>>;
+    } : never;
     /** Creates a credential from a payment-required response by routing to the correct method. */
     createCredential: (response: Transport.ResponseOf<transport>, context?: AnyContextFor<FlattenMethods<methods>> | undefined, options?: createCredential.Options<FlattenMethods<methods>, transport> | undefined) => Promise<string>;
     /** Register a client event handler by canonical event name. */
@@ -116,9 +127,11 @@ export declare namespace preparePayment {
 }
 export declare namespace prepareRequest {
     /** Options for preparing a request-bound payment. */
-    type Options<methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[]> = Omit<preparePayment.Options<methods, Transport.Transport<RequestInit, Response>>, 'request'> & {
+    type Options<methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[], requirePayment extends boolean = false> = Omit<preparePayment.Options<methods, Transport.Transport<RequestInit, Response>>, 'request'> & {
         /** Maximum redirects followed before rejecting the request. @default 20 */
         maxRedirects?: number | undefined;
+        /** Throw when the response does not require payment. @default false */
+        requirePayment?: requirePayment | undefined;
     };
 }
 export declare namespace createCredential {

package/dist/client/Mppx.js

@@ -148,7 +148,7 @@ export function create(config) {
         }
     }
     async function prepareRequest(input, init, options) {
-        const { maxRedirects = 20, ...paymentOptions } = options ?? {};
+        const { maxRedirects = 20, requirePayment = false, ...paymentOptions } = options ?? {};
         const preparedHttp = await prepareHttpRequest({
             acceptPayment: acceptPayment.header,
             acceptPaymentPolicy,
@@ -159,8 +159,16 @@ export function create(config) {
             signer: attestationSigner,
         });
         const requestInit = requestToInit(preparedHttp.replayRequest, preparedHttp.body);
-        if (!(await transport.isPaymentRequired(preparedHttp.response, requestInit)))
-            throw new Error('Response does not require payment.');
+        if (!(await transport.isPaymentRequired(preparedHttp.response, requestInit))) {
+            if (requirePayment)
+                throw new Error('Response does not require payment.');
+            return Object.freeze({
+                payment: undefined,
+                request: preparedHttp.request,
+                response: preparedHttp.response,
+                redirects: preparedHttp.redirects,
+            });
+        }
         const payment = (await preparePayment(preparedHttp.response, {
             ...paymentOptions,
             request: requestInit,
@@ -176,12 +184,9 @@ export function create(config) {
                 });
             return payment.createCredential(context);
         });
-        return Object.freeze({
+        const preparedPayment = Object.freeze({
             ...payment,
             createCredential: createRequestCredential,
-            request: preparedHttp.request,
-            response: preparedHttp.response,
-            redirects: preparedHttp.redirects,
             async pay(context) {
                 const credential = await createRequestCredential(context);
                 const paidInit = payment.setCredential(requestToInit(preparedHttp.replayRequest, preparedHttp.body), credential);
@@ -191,6 +196,12 @@ export function create(config) {
                 });
             },
         });
+        return Object.freeze({
+            payment: preparedPayment,
+            request: preparedHttp.request,
+            response: preparedHttp.response,
+            redirects: preparedHttp.redirects,
+        });
     }
     return {
         fetch,

package/dist/client/internal/protocols/X402.js

@@ -17,8 +17,6 @@ export function x402() {
             if (!header)
                 return [];
             const paymentRequired = x402_Header.decodePaymentRequiredEnvelope(header);
-            if (response.url && paymentRequired.resource.url !== response.url)
-                throw new Error('x402 payment-required resource does not match response URL.');
             return paymentRequired.accepts.flatMap((rawAccepted, index) => {
                 const parsed = x402_Types.PaymentRequirementsSchema.safeParse(rawAccepted);
                 if (!parsed.success)

package/dist/internal/version.d.ts

@@ -1,5 +1,5 @@
 /** Current mppx package version. */
-export declare const version = "0.10.0";
+export declare const version = "0.11.0";
 /** Canonical SDK identifier for this mppx release. */
-export declare const sdkIdentifier = "mppx/0.10.0";
+export declare const sdkIdentifier = "mppx/0.11.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/internal/version.js

@@ -1,6 +1,6 @@
 // Generated by scripts/sync-version.ts.
 /** Current mppx package version. */
-export const version = '0.10.0';
+export const version = '0.11.0';
 /** Canonical SDK identifier for this mppx release. */
 export const sdkIdentifier = `mppx/${version}`;
 //# sourceMappingURL=version.js.map

package/dist/stripe/server/Methods.js

@@ -121,13 +121,21 @@ export function stripe(parameters) {
         }));
     }
     function makeTempoSession(params) {
-        const { recipient, ...rest } = params;
+        const { recipient, onSessionSettlement, ...rest } = params;
         return tempoSession({
             currency: tempoCurrency,
             recipient,
             ...(!livemode && { testnet: true }),
             ...(hostedTempoFeePayer && { feePayer: hostedTempoFeePayer }),
             ...rest,
+            async onSessionSettlement(context) {
+                await tempoPaymentHandler({
+                    intent: 'session',
+                    receipt: { reference: context.txHash },
+                    request: { amount: context.delta.toString() },
+                });
+                await onSessionSettlement?.(context);
+            },
         });
     }
     function makeBaseCharge(params) {
@@ -283,7 +291,7 @@ function customRails(additional) {
 }
 function createPaymentSuccessHandler(client, network, connect, metadata) {
     return (params) => {
-        const { challenge, receipt, request, requestInput } = params;
+        const { challenge, intent, receipt, request, requestInput } = params;
         if (receipt?.reference && request?.amount) {
             const paymentIntentOptionsInput = requestInput?.paymentIntentOptions;
             const paymentIntentOptions = typeof paymentIntentOptionsInput === 'function' ? undefined : paymentIntentOptionsInput;
@@ -300,7 +308,7 @@ function createPaymentSuccessHandler(client, network, connect, metadata) {
                 reference: receipt.reference,
                 amount: String(request.amount),
                 ...(connect && { connect }),
-                analyticsMetadata: buildAnalytics({ challenge }),
+                analyticsMetadata: buildAnalytics({ challenge, intent }),
                 ...(Object.keys(resolvedPaymentIntentOptions).length > 0 && {
                     paymentIntentOptions: resolvedPaymentIntentOptions,
                 }),

package/dist/stripe/server/internal/analytics.d.ts

@@ -2,5 +2,6 @@ import type * as Challenge from '../../../Challenge.js';
 /** Builds Stripe metadata used to identify and analyze MPP payments. */
 export declare function buildAnalytics(parameters: {
     challenge?: Pick<Challenge.Challenge, 'id' | 'intent'> | undefined;
+    intent?: string | undefined;
 }): Record<string, string>;
 //# sourceMappingURL=analytics.d.ts.map

package/dist/stripe/server/internal/analytics.js

@@ -2,13 +2,13 @@ import { sdkIdentifier } from '../../../internal/version.js';
 import { machinePaymentMetadata } from '../../internal/constants.js';
 /** Builds Stripe metadata used to identify and analyze MPP payments. */
 export function buildAnalytics(parameters) {
-    const { challenge } = parameters;
+    const { challenge, intent = challenge?.intent } = parameters;
     const metadata = {
         ...machinePaymentMetadata,
         mpp_sdk: sdkIdentifier,
+        ...(intent && { mpp_intent: intent }),
         ...(challenge && {
             mpp_challenge_id: challenge.id,
-            mpp_intent: challenge.intent,
         }),
     };
     return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, [...value].slice(0, 500).join('')]));

package/dist/stripe/server/internal/record-payment.js

@@ -13,9 +13,9 @@ export function recordCryptoPayment(client, parameters) {
     const { network, reference, amount, connect, analyticsMetadata, paymentIntentOptions } = parameters;
     const { customer, hooks, metadata, receipt_email } = paymentIntentOptions ?? {};
     const { stripeNetworkName, tokenDecimals } = NETWORK_CONFIG[network];
-    const amountCents = Math.round(Number(amount) / 10 ** (tokenDecimals - 2));
+    const amountCents = Number(BigInt(amount) / 10n ** BigInt(tokenDecimals - 2));
     if (amountCents < 1) {
-        console.warn(`[stripe] skipping PI recording: ${amount} raw units on ${network} rounds to ${amountCents} cents (below Stripe minimum)`);
+        console.warn(`[stripe] skipping PI recording: ${amount} raw units on ${network} floors to ${amountCents} cents (below Stripe minimum)`);
         return Promise.resolve();
     }
     const requiredParams = {

package/dist/tempo/Methods.d.ts

@@ -35,6 +35,7 @@ export declare const charge: {
             }, z.core.$strip>], "type">;
         };
         request: z.ZodMiniPipe<z.ZodMiniObject<{
+            machineTokenEnabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             amount: z.ZodMiniString<string>;
             chainId: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             currency: z.ZodMiniString<string>;
@@ -42,7 +43,7 @@ export declare const charge: {
             description: z.ZodMiniOptional<z.ZodMiniString<string>>;
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             feePayer: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniCustom<Account, Account>]>, z.ZodMiniTransform<boolean, boolean | Account>>>;
-            memo: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            memo: z.ZodMiniOptional<z.ZodMiniNever>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
             splits: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
                 amount: z.ZodMiniString<string>;
@@ -60,9 +61,9 @@ export declare const charge: {
             recipient?: string | undefined;
             amount: string;
             methodDetails?: {
+                machineTokenEnabled?: boolean | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
-                memo?: string | undefined;
                 splits?: {
                     memo?: string | undefined;
                     recipient: `0x${string}`;
@@ -71,6 +72,7 @@ export declare const charge: {
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -78,7 +80,7 @@ export declare const charge: {
             description?: string | undefined;
             externalId?: string | undefined;
             feePayer?: boolean | undefined;
-            memo?: string | undefined;
+            memo?: undefined;
             recipient?: string | undefined;
             splits?: {
                 amount: string;

package/dist/tempo/Methods.js

@@ -82,6 +82,7 @@ export const charge = Method.from({
         },
         request: z.pipe(z
             .object({
+            machineTokenEnabled: z.optional(z.boolean()),
             amount: z.amount(),
             chainId: z.optional(z.number()),
             currency: z.string(),
@@ -89,7 +90,7 @@ export const charge = Method.from({
             description: z.optional(z.string()),
             externalId: z.optional(z.string()),
             feePayer: z.optional(z.pipe(z.union([z.boolean(), z.custom()]), z.transform((v) => (typeof v === 'object' ? true : v)))),
-            memo: z.optional(z.hash()),
+            memo: z.optional(z.never()),
             recipient: z.optional(z.string()),
             splits: z.optional(z.array(split).check(z.minLength(1), z.maxLength(10))),
             supportedModes: z.optional(z.array(z.enum(chargeModes)).check(z.minLength(1))),
@@ -101,19 +102,19 @@ export const charge = Method.from({
             const splitTotal = splits.reduce((sum, split) => sum + parseUnits(split.amount, decimals), 0n);
             return (splits.every((split) => parseUnits(split.amount, decimals) > 0n) &&
                 splitTotal < totalAmount);
-        }, 'Invalid splits')), z.transform(({ amount, chainId, decimals, feePayer, memo, splits, supportedModes, ...rest }) => ({
+        }, 'Invalid splits')), z.transform(({ machineTokenEnabled, amount, chainId, decimals, feePayer, memo: _memo, splits, supportedModes, ...rest }) => ({
             ...rest,
             amount: parseUnits(amount, decimals).toString(),
-            ...(chainId !== undefined ||
+            ...(machineTokenEnabled !== undefined ||
+                chainId !== undefined ||
                 feePayer !== undefined ||
-                memo !== undefined ||
                 splits !== undefined ||
                 supportedModes !== undefined
                 ? {
                     methodDetails: {
+                        ...(machineTokenEnabled !== undefined && { machineTokenEnabled }),
                         ...(chainId !== undefined && { chainId }),
                         ...(feePayer !== undefined && { feePayer }),
-                        ...(memo !== undefined && { memo }),
                         ...(splits !== undefined && {
                             splits: splits.map((split) => ({
                                 ...split,

package/dist/tempo/client/Charge.d.ts

@@ -1,4 +1,4 @@
-import { type Address } from 'viem';
+import type { Address } from 'viem';
 import * as Method from '../../Method.js';
 import * as Account from '../../viem/Account.js';
 import * as Client from '../../viem/Client.js';
@@ -42,6 +42,7 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
             }, z.core.$strip>], "type">;
         };
         request: z.ZodMiniPipe<z.ZodMiniObject<{
+            machineTokenEnabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             amount: z.ZodMiniString<string>;
             chainId: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             currency: z.ZodMiniString<string>;
@@ -49,7 +50,7 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
             description: z.ZodMiniOptional<z.ZodMiniString<string>>;
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             feePayer: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniCustom<import("viem").Account, import("viem").Account>]>, z.ZodMiniTransform<boolean, boolean | import("viem").Account>>>;
-            memo: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            memo: z.ZodMiniOptional<z.ZodMiniNever>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
             splits: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniObject<{
                 amount: z.ZodMiniString<string>;
@@ -67,9 +68,9 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
             recipient?: string | undefined;
             amount: string;
             methodDetails?: {
+                machineTokenEnabled?: boolean | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
-                memo?: string | undefined;
                 splits?: {
                     memo?: string | undefined;
                     recipient: `0x${string}`;
@@ -78,6 +79,7 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -85,7 +87,7 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
             description?: string | undefined;
             externalId?: string | undefined;
             feePayer?: boolean | undefined;
-            memo?: string | undefined;
+            memo?: undefined;
             recipient?: string | undefined;
             splits?: {
                 amount: string;

package/dist/tempo/client/Charge.js

@@ -1,4 +1,3 @@
-import { isAddressEqual } from 'viem';
 import { prepareTransactionRequest, sendCallsSync, sendTransactionSync, signTypedData, signTransaction, } from 'viem/actions';
 import { Actions } from 'viem/tempo';
 import { tempo as tempo_chain } from 'viem/tempo/chains';
@@ -12,9 +11,9 @@ import * as AutoSwap from '../internal/auto-swap.js';
 import * as Charge_internal from '../internal/charge.js';
 import * as defaults from '../internal/defaults.js';
 import { defaultFeeTokens, resolveFeeToken } from '../internal/fee-token.js';
+import * as MachineTokenCharge from '../internal/machine-token-charge.js';
 import * as Proof from '../internal/proof.js';
 import * as Methods from '../Methods.js';
-import { mach } from '../Tokens.js';
 const chargeContextSchema = z.object({
     account: z.optional(z.custom()),
     autoSwap: z.optional(z.custom()),
@@ -98,9 +97,12 @@ export function charge(parameters = {}) {
                 });
             }
             const currency = request.currency;
-            const memo = methodDetails?.memo
-                ? methodDetails.memo
-                : Attribution.encode({ challengeId: challenge.id, clientId, serverId: challenge.realm });
+            const isMachineTokenCurrency = MachineTokenCharge.isMachineToken({ chainId, currency });
+            const memo = Attribution.encode({
+                challengeId: challenge.id,
+                clientId,
+                serverId: challenge.realm,
+            });
             const transfers = Charge_internal.getTransfers({
                 amount,
                 methodDetails: {
@@ -116,14 +118,66 @@ export function charge(parameters = {}) {
                 token: currency,
             }));
             const autoSwap = AutoSwap.resolve(context?.autoSwap ?? parameters.autoSwap, AutoSwap.defaultCurrencies);
-            const account = (await parameters.resolveAccount?.({
+            const machineTokenEnabled = methodDetails?.machineTokenEnabled === true;
+            const resolveAccount = async (calls) => (await parameters.resolveAccount?.({
                 account: defaultAccount,
                 chainId,
                 operation: {
                     kind: 'executeCalls',
-                    ...(autoSwap ? {} : { calls: transferCalls }),
+                    ...(calls ? { calls } : {}),
                 },
             })) ?? defaultAccount;
+            const machineTokenCandidate = machineTokenEnabled
+                ? MachineTokenCharge.getRoute({ chainId, currency, transfers })
+                : undefined;
+            let account = defaultAccount;
+            let machineTokenRoute;
+            if (machineTokenCandidate) {
+                const machineTokenAccount = await (async () => {
+                    try {
+                        return await resolveAccount(machineTokenCandidate.calls);
+                    }
+                    catch {
+                        // A machine-token route is optional. A scoped account that cannot
+                        // execute it may still be able to satisfy the direct payment.
+                        return undefined;
+                    }
+                })();
+                if (machineTokenAccount) {
+                    machineTokenRoute = await MachineTokenCharge.findRoute(client, {
+                        account: machineTokenAccount.address,
+                        chainId,
+                        currency,
+                        transfers,
+                    });
+                    if (machineTokenRoute)
+                        account = machineTokenAccount;
+                }
+            }
+            let swapCalls;
+            if (!machineTokenRoute) {
+                account = await resolveAccount(autoSwap ? undefined : transferCalls);
+                swapCalls = autoSwap
+                    ? await AutoSwap.findCalls(client, {
+                        account: account.address,
+                        amountOut: BigInt(amount),
+                        tokenOut: currency,
+                        tokenIn: autoSwap.tokenIn,
+                        slippage: autoSwap.slippage,
+                    })
+                    : undefined;
+            }
+            const calls = machineTokenRoute?.calls ?? [...(swapCalls ?? []), ...transferCalls];
+            const allowedFeeTokens = defaultFeeTokens(chainId);
+            const feeToken = machineTokenRoute || isMachineTokenCurrency
+                ? await resolveFeeToken({
+                    account: account.address,
+                    allowedTokens: allowedFeeTokens,
+                    candidateTokens: allowedFeeTokens,
+                    client,
+                    prioritizeCandidates: true,
+                })
+                : undefined;
             const mode = (() => {
                 const explicitMode = context?.mode ?? parameters.mode;
                 if (explicitMode) {
@@ -136,27 +190,6 @@ export function charge(parameters = {}) {
                     return preferredMode;
                 return supportedModes[0];
             })();
-            const swapCalls = autoSwap
-                ? await AutoSwap.findCalls(client, {
-                    account: account.address,
-                    amountOut: BigInt(amount),
-                    tokenOut: currency,
-                    tokenIn: autoSwap.tokenIn,
-                    slippage: autoSwap.slippage,
-                })
-                : undefined;
-            const calls = [...(swapCalls ?? []), ...transferCalls];
-            const machAddress = mach.addresses[chainId];
-            const allowedFeeTokens = defaultFeeTokens(chainId);
-            const feeToken = machAddress && isAddressEqual(currency, machAddress)
-                ? await resolveFeeToken({
-                    account: account.address,
-                    allowedTokens: allowedFeeTokens,
-                    candidateTokens: allowedFeeTokens,
-                    client,
-                    prioritizeCandidates: true,
-                })
-                : undefined;
             const validBefore = (() => {
                 const defaultExpiry = Math.floor(Date.now() / 1000) + 25;
                 if (!challenge.expires)

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

@@ -37,6 +37,7 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             }, 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>;
@@ -44,7 +45,7 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             description: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             externalId: 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>>>;
-            memo: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            memo: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNever>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             splits: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniObject<{
                 amount: import("zod/mini").ZodMiniString<string>;
@@ -62,9 +63,9 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             recipient?: string | undefined;
             amount: string;
             methodDetails?: {
+                machineTokenEnabled?: boolean | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
-                memo?: string | undefined;
                 splits?: {
                     memo?: string | undefined;
                     recipient: `0x${string}`;
@@ -73,6 +74,7 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -80,7 +82,7 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             description?: string | undefined;
             externalId?: string | undefined;
             feePayer?: boolean | undefined;
-            memo?: string | undefined;
+            memo?: undefined;
             recipient?: string | undefined;
             splits?: {
                 amount: string;

package/dist/tempo/index.d.ts

@@ -3,5 +3,6 @@ export * as Methods from './Methods.js';
 export * as Session from './session/index.js';
 export * as SessionLegacy from './legacy/index.js';
 export * as Subscription from './subscription/index.js';
-export { mach } from './Tokens.js';
+/** Canonical first-party machine-token deployments by Tempo chain ID. */
+export { machineToken as machineTokenDeployments } from './internal/defaults.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tempo/index.js

@@ -3,5 +3,6 @@ export * as Methods from './Methods.js';
 export * as Session from './session/index.js';
 export * as SessionLegacy from './legacy/index.js';
 export * as Subscription from './subscription/index.js';
-export { mach } from './Tokens.js';
+/** Canonical first-party machine-token deployments by Tempo chain ID. */
+export { machineToken as machineTokenDeployments } from './internal/defaults.js';
 //# sourceMappingURL=index.js.map

package/dist/tempo/internal/defaults.d.ts

@@ -16,6 +16,17 @@ export declare const currency: {
     readonly 4217: "0x20C000000000000000000000b9537d11c60E8b50";
     readonly 42431: "0x20c0000000000000000000000000000000000000";
 };
+/** Immutable canonical first-party machine-token deployments used by charge routes. */
+export declare const machineToken: Readonly<{
+    readonly 4217: Readonly<{
+        swap: "0xF72E5107c32C655ffA7539a3C8e97B7C3cE16A3F";
+        token: "0x20c000000000000000000000f37de3740ADec032";
+    }>;
+    readonly 42431: Readonly<{
+        swap: "0xd05f8EdFBB54Da0d765C9fE9b2B3f7d2E3a8C466";
+        token: "0x20c000000000000000000000f37de3740ADec032";
+    }>;
+}>;
 /**
  * Default token decimals for TIP-20 stablecoins (e.g. pathUSD, USDC).
  *

package/dist/tempo/internal/defaults.js

@@ -14,6 +14,17 @@ export const currency = {
     [chainId.mainnet]: tokens.usdc,
     [chainId.testnet]: tokens.pathUsd,
 };
+/** Immutable canonical first-party machine-token deployments used by charge routes. */
+export const machineToken = Object.freeze({
+    [chainId.mainnet]: Object.freeze({
+        swap: '0xF72E5107c32C655ffA7539a3C8e97B7C3cE16A3F',
+        token: '0x20c000000000000000000000f37de3740ADec032',
+    }),
+    [chainId.testnet]: Object.freeze({
+        swap: '0xd05f8EdFBB54Da0d765C9fE9b2B3f7d2E3a8C466',
+        token: '0x20c000000000000000000000f37de3740ADec032',
+    }),
+});
 /**
  * Default token decimals for TIP-20 stablecoins (e.g. pathUSD, USDC).
  *