mppx 0.10.1 → 0.11.0

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.1";
+export declare const version = "0.11.0";
 /** Canonical SDK identifier for this mppx release. */
-export declare const sdkIdentifier = "mppx/0.10.1";
+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.1';
+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).
  *

package/dist/tempo/internal/machine-token-charge.d.ts

@@ -0,0 +1,56 @@
+import type * as Hex from 'ox/Hex';
+import { type Address, type Client } from 'viem';
+type Call = {
+    data?: Hex.Hex | undefined;
+    to?: Address | undefined;
+    value?: bigint | undefined;
+};
+type RouteCall = {
+    data: Hex.Hex;
+    to: Address;
+};
+type Route = {
+    calls: readonly [RouteCall, RouteCall];
+    settlementSender: Address;
+    transfers: readonly [{
+        amount: bigint;
+        memo: Hex.Hex;
+        recipient: Address;
+    }];
+};
+type Transfer = {
+    amount: bigint | string;
+    memo?: string | undefined;
+    recipient: Address;
+};
+/** Returns whether a first-party machine-token charge route is deployed on a chain. */
+export declare function isSupported(chainId: number | undefined): boolean;
+/** Returns whether a currency is the machine token for a supported chain. */
+export declare function isMachineToken(parameters: {
+    chainId: number | undefined;
+    currency: Address;
+}): boolean;
+/** Resolves the canonical first-party settlement route for a compatible charge. */
+export declare function getRoute(parameters: {
+    chainId: number | undefined;
+    currency: Address;
+    transfers: readonly Transfer[];
+}): Route | undefined;
+/** Builds and simulates the first-party settlement route. */
+export declare function findRoute(client: Client, parameters: {
+    account: Address;
+    chainId: number;
+    currency: Address;
+    transfers: readonly Transfer[];
+}): Promise<Route | undefined>;
+/** Matches an exact first-party settlement route. */
+export declare function matchRoute(parameters: {
+    calls: readonly Call[];
+    chainId: number | undefined;
+    currency: Address;
+    transfers: readonly Transfer[];
+}): Route | undefined;
+/** Returns the trusted sender that settles the configured charge route on a chain. */
+export declare function getSettlementSender(chainId: number | undefined): Address | undefined;
+export {};
+//# sourceMappingURL=machine-token-charge.d.ts.map

package/dist/tempo/internal/machine-token-charge.js

@@ -0,0 +1,108 @@
+import { decodeFunctionData, encodeFunctionData, isAddress, isAddressEqual, parseAbi, } from 'viem';
+import { call, readContract } from 'viem/actions';
+import { Abis, Actions } from 'viem/tempo';
+import * as defaults from './defaults.js';
+const machineTokenSwapperAbi = parseAbi([
+    'function swapTo(address inputToken,uint256 amount,address targetToken,address recipient,bytes32 memo)',
+]);
+function getDeployment(chainId) {
+    if (chainId === undefined)
+        return undefined;
+    return defaults.machineToken[chainId];
+}
+/** Returns whether a first-party machine-token charge route is deployed on a chain. */
+export function isSupported(chainId) {
+    return !!getDeployment(chainId);
+}
+/** Returns whether a currency is the machine token for a supported chain. */
+export function isMachineToken(parameters) {
+    const deployment = getDeployment(parameters.chainId);
+    return (!!deployment &&
+        isAddress(parameters.currency, { strict: false }) &&
+        isAddressEqual(parameters.currency, deployment.token));
+}
+/** Resolves the canonical first-party settlement route for a compatible charge. */
+export function getRoute(parameters) {
+    const deployment = getDeployment(parameters.chainId);
+    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
+    if (!deployment || !transfer?.memo)
+        return undefined;
+    const amount = BigInt(transfer.amount);
+    const memo = transfer.memo;
+    return {
+        calls: [
+            {
+                data: encodeFunctionData({
+                    abi: Abis.tip20,
+                    functionName: 'approve',
+                    args: [deployment.swap, amount],
+                }),
+                to: deployment.token,
+            },
+            {
+                data: encodeFunctionData({
+                    abi: machineTokenSwapperAbi,
+                    functionName: 'swapTo',
+                    args: [deployment.token, amount, parameters.currency, transfer.recipient, memo],
+                }),
+                to: deployment.swap,
+            },
+        ],
+        settlementSender: deployment.swap,
+        transfers: [{ amount, memo, recipient: transfer.recipient }],
+    };
+}
+/** Builds and simulates the first-party settlement route. */
+export async function findRoute(client, parameters) {
+    const route = getRoute(parameters);
+    if (!route)
+        return undefined;
+    try {
+        const balance = await readContract(client, Actions.token.getBalance.call(client, {
+            account: parameters.account,
+            token: route.calls[0].to,
+        }));
+        if (balance < route.transfers[0].amount)
+            return undefined;
+        await call(client, { account: parameters.account, calls: route.calls });
+        return route;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Matches an exact first-party settlement route. */
+export function matchRoute(parameters) {
+    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
+    const swap = parameters.calls[1];
+    if (!transfer || parameters.calls.length !== 2 || !swap?.data)
+        return undefined;
+    try {
+        const decoded = decodeFunctionData({ abi: machineTokenSwapperAbi, data: swap.data });
+        const route = getRoute({
+            ...parameters,
+            transfers: [{ ...transfer, memo: transfer.memo ?? decoded.args[4] }],
+        });
+        if (!route)
+            return undefined;
+        if (parameters.calls.some((call, index) => {
+            const expected = route.calls[index];
+            return (!call.data ||
+                !call.to ||
+                !expected ||
+                (call.value ?? 0n) !== 0n ||
+                !isAddressEqual(call.to, expected.to) ||
+                call.data.toLowerCase() !== expected.data.toLowerCase());
+        }))
+            return undefined;
+        return route;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Returns the trusted sender that settles the configured charge route on a chain. */
+export function getSettlementSender(chainId) {
+    return getDeployment(chainId)?.swap;
+}
+//# sourceMappingURL=machine-token-charge.js.map

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

@@ -45,6 +45,8 @@ export declare namespace charge {
         } | undefined;
     };
     type Parameters = {
+        /** Enables first-party machine-token funding through the canonical swapper. */
+        machineTokenEnabled?: boolean | undefined;
         /** Render payment page when Accept header is text/html (e.g. in browsers) */
         html?: boolean | Html.Config | undefined;
         /**
@@ -99,6 +101,7 @@ export declare namespace charge {
          * relay broadcasts pull credentials, while it recognizes a push
          * credential as already broadcast and returns its receipt without sending
          * it again.
+         *
          */
         relay?: RelayOptions | undefined;
         /**