mppx 0.8.17 → 0.8.18

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>;
@@ -60,6 +61,7 @@ export declare const charge: {
             recipient?: string | undefined;
             amount: string;
             methodDetails?: {
+                machineTokenEnabled?: boolean | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
                 memo?: string | undefined;
@@ -71,6 +73,7 @@ export declare const charge: {
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -102,6 +105,7 @@ export declare const session: {
         credential: {
             payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
                 action: z.ZodMiniLiteral<"open">;
+                authorizationSignature: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 authorizedSigner: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 channelId: z.ZodMiniString<string>;
                 cumulativeAmount: z.ZodMiniString<string>;
@@ -118,15 +122,18 @@ export declare const session: {
                 type: z.ZodMiniLiteral<"transaction">;
             }, z.core.$strip>, z.ZodMiniObject<{
                 action: z.ZodMiniLiteral<"voucher">;
+                authorizationSignature: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 channelId: z.ZodMiniString<string>;
                 cumulativeAmount: z.ZodMiniString<string>;
                 descriptor: z.ZodMiniOptional<z.ZodMiniCustom<PrecompileChannel.ChannelDescriptor, PrecompileChannel.ChannelDescriptor>>;
                 signature: z.ZodMiniString<string>;
             }, z.core.$strip>, z.ZodMiniObject<{
                 action: z.ZodMiniLiteral<"close">;
+                authorizationSignature: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 channelId: z.ZodMiniString<string>;
                 cumulativeAmount: z.ZodMiniString<string>;
                 descriptor: z.ZodMiniOptional<z.ZodMiniCustom<PrecompileChannel.ChannelDescriptor, PrecompileChannel.ChannelDescriptor>>;
+                refundSignature: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 signature: z.ZodMiniString<string>;
             }, z.core.$strip>], "action">;
         };
@@ -138,6 +145,8 @@ export declare const session: {
             decimals: z.ZodMiniNumber<number>;
             escrowContract: 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>>>;
+            feeToken: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            machineTokenEnabled: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
             minVoucherDelta: z.ZodMiniOptional<z.ZodMiniString<string>>;
             operator: z.ZodMiniOptional<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -160,6 +169,8 @@ export declare const session: {
                 minVoucherDelta?: string | undefined;
                 chainId?: number | undefined;
                 feePayer?: boolean | undefined;
+                feeToken?: string | undefined;
+                machineTokenEnabled?: boolean | undefined;
                 operator?: string | undefined;
                 sessionProtocol?: "v1" | "v2" | undefined;
                 sessionSnapshot?: SessionSnapshot | undefined;
@@ -172,6 +183,8 @@ export declare const session: {
             decimals: number;
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
+            feeToken?: string | undefined;
+            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;

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(),
@@ -101,16 +102,18 @@ 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, 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 }),
@@ -141,6 +144,7 @@ export const session = Method.from({
             payload: z.discriminatedUnion('action', [
                 z.object({
                     action: z.literal('open'),
+                    authorizationSignature: z.optional(z.signature()),
                     authorizedSigner: z.optional(z.string()),
                     channelId: z.hash(),
                     cumulativeAmount: z.amount(),
@@ -159,6 +163,7 @@ export const session = Method.from({
                 }),
                 z.object({
                     action: z.literal('voucher'),
+                    authorizationSignature: z.optional(z.signature()),
                     channelId: z.hash(),
                     cumulativeAmount: z.amount(),
                     descriptor: z.optional(z.custom()),
@@ -166,9 +171,11 @@ export const session = Method.from({
                 }),
                 z.object({
                     action: z.literal('close'),
+                    authorizationSignature: z.optional(z.signature()),
                     channelId: z.hash(),
                     cumulativeAmount: z.amount(),
                     descriptor: z.optional(z.custom()),
+                    refundSignature: z.optional(z.signature()),
                     signature: z.signature(),
                 }),
             ]),
@@ -182,6 +189,8 @@ export const session = Method.from({
             decimals: z.number(),
             escrowContract: z.optional(z.string()),
             feePayer: z.optional(z.pipe(z.union([z.boolean(), z.custom()]), z.transform((v) => (typeof v === 'object' ? true : v)))),
+            feeToken: z.optional(z.address()),
+            machineTokenEnabled: z.optional(z.boolean()),
             minVoucherDelta: z.optional(z.amount()),
             operator: z.optional(z.address()),
             recipient: z.optional(z.string()),
@@ -190,7 +199,7 @@ export const session = Method.from({
             suggestedDeposit: z.optional(z.amount()),
             unitType: z.string(),
         })
-            .check(z.refine(({ amount, decimals }) => parseUnits(amount, decimals) > 0n, 'Session amount must be greater than 0')), z.transform(({ amount, chainId, channelId, decimals, escrowContract, feePayer, minVoucherDelta, operator, sessionProtocol, sessionSnapshot, suggestedDeposit, ...rest }) => ({
+            .check(z.refine(({ amount, decimals }) => parseUnits(amount, decimals) > 0n, 'Session amount must be greater than 0')), z.transform(({ amount, chainId, channelId, decimals, escrowContract, feePayer, feeToken, machineTokenEnabled, minVoucherDelta, operator, sessionProtocol, sessionSnapshot, suggestedDeposit, ...rest }) => ({
             ...rest,
             amount: parseUnits(amount, decimals).toString(),
             ...(suggestedDeposit
@@ -206,6 +215,8 @@ export const session = Method.from({
                 }),
                 ...(chainId !== undefined && { chainId }),
                 ...(feePayer !== undefined && { feePayer }),
+                ...(feeToken !== undefined && { feeToken }),
+                ...(machineTokenEnabled !== undefined && { machineTokenEnabled }),
                 ...(operator !== undefined && { operator }),
                 ...(sessionProtocol !== undefined && {
                     [Constants.MethodDetailKeys.sessionProtocol]: sessionProtocol,

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

@@ -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>;
@@ -67,6 +68,7 @@ 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;
@@ -78,6 +80,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;

package/dist/tempo/client/Charge.js

@@ -1,4 +1,4 @@
-import { prepareTransactionRequest, sendCallsSync, signTypedData, signTransaction, } from 'viem/actions';
+import { prepareTransactionRequest, sendCallsSync, sendTransactionSync, signTypedData, signTransaction, } from 'viem/actions';
 import { Actions } from 'viem/tempo';
 import { tempo as tempo_chain } from 'viem/tempo/chains';
 import * as Credential from '../../Credential.js';
@@ -10,6 +10,7 @@ import * as Attribution from '../Attribution.js';
 import * as AutoSwap from '../internal/auto-swap.js';
 import * as Charge_internal from '../internal/charge.js';
 import * as defaults from '../internal/defaults.js';
+import * as MachineTokenCharge from '../internal/machine-token-charge.js';
 import * as Proof from '../internal/proof.js';
 import * as Methods from '../Methods.js';
 const chargeContextSchema = z.object({
@@ -105,12 +106,13 @@ export function charge(parameters = {}) {
                 token: currency,
             }));
             const autoSwap = AutoSwap.resolve(context?.autoSwap ?? parameters.autoSwap, AutoSwap.defaultCurrencies);
+            const machineTokenEnabled = methodDetails?.machineTokenEnabled === true;
             const account = (await parameters.resolveAccount?.({
                 account: defaultAccount,
                 chainId,
                 operation: {
                     kind: 'executeCalls',
-                    ...(autoSwap ? {} : { calls: transferCalls }),
+                    ...(autoSwap || machineTokenEnabled ? {} : { calls: transferCalls }),
                 },
             })) ?? defaultAccount;
             const mode = (() => {
@@ -125,7 +127,15 @@ export function charge(parameters = {}) {
                     return preferredMode;
                 return supportedModes[0];
             })();
-            const swapCalls = autoSwap
+            const machineTokenRoute = machineTokenEnabled
+                ? await MachineTokenCharge.findRoute(client, {
+                    account: account.address,
+                    chainId,
+                    currency,
+                    transfers,
+                })
+                : undefined;
+            const swapCalls = !machineTokenRoute && autoSwap
                 ? await AutoSwap.findCalls(client, {
                     account: account.address,
                     amountOut: BigInt(amount),
@@ -134,7 +144,7 @@ export function charge(parameters = {}) {
                     slippage: autoSwap.slippage,
                 })
                 : undefined;
-            const calls = [...(swapCalls ?? []), ...transferCalls];
+            const calls = machineTokenRoute?.calls ?? [...(swapCalls ?? []), ...transferCalls];
             const validBefore = (() => {
                 const defaultExpiry = Math.floor(Date.now() / 1000) + 25;
                 if (!challenge.expires)
@@ -143,11 +153,23 @@ export function charge(parameters = {}) {
                 return Math.min(defaultExpiry, challengeExpiry);
             })();
             if (mode === 'push') {
-                const { receipts } = await sendCallsSync(client, {
-                    account,
-                    calls: calls,
-                    experimental_fallback: true,
-                });
+                const { receipts } = account.type === 'local'
+                    ? {
+                        receipts: [
+                            await sendTransactionSync(client, {
+                                account,
+                                calls,
+                                nonceKey: 'expiring',
+                                validBefore,
+                            }),
+                        ],
+                    }
+                    : await sendCallsSync(client, {
+                        account,
+                        calls: calls,
+                        experimental_fallback: calls.length === 1,
+                        forceAtomic: calls.length > 1,
+                    });
                 const hash = receipts?.[0]?.transactionHash;
                 if (!hash)
                     throw new Error('No transaction receipt returned.');

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>;
@@ -62,6 +63,7 @@ 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;
@@ -73,6 +75,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;
@@ -104,6 +107,7 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
         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>;
@@ -120,15 +124,18 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 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">;
         };
@@ -140,6 +147,8 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             decimals: import("zod/mini").ZodMiniNumber<number>;
             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>>;
@@ -162,6 +171,8 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 minVoucherDelta?: string | undefined;
                 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;
@@ -174,6 +185,8 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             decimals: number;
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
+            feeToken?: string | undefined;
+            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;

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

@@ -16,6 +16,17 @@ export declare const currency: {
     readonly 4217: "0x20C000000000000000000000b9537d11c60E8b50";
     readonly 42431: "0x20c0000000000000000000000000000000000000";
 };
+/** Unified first-party machine-token deployments used by charges and sessions. */
+export declare const machineToken: {
+    readonly 4217: {
+        readonly swap: '0xd588ED9Ae08643A450157Adaf61c3C0C1BBd0dbb';
+        readonly token: '0x20c0000000000000000000006637932dE5413804';
+    };
+    readonly 42431: {
+        readonly swap: '0xd588ED9Ae08643A450157Adaf61c3C0C1BBd0dbb';
+        readonly token: '0x20c0000000000000000000006637932dE5413804';
+    };
+};
 /**
  * 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,
 };
+/** Unified first-party machine-token deployments used by charges and sessions. */
+export const machineToken = {
+    [chainId.mainnet]: {
+        swap: '0xd588ED9Ae08643A450157Adaf61c3C0C1BBd0dbb',
+        token: '0x20c0000000000000000000006637932dE5413804',
+    },
+    [chainId.testnet]: {
+        swap: '0xd588ED9Ae08643A450157Adaf61c3C0C1BBd0dbb',
+        token: '0x20c0000000000000000000006637932dE5413804',
+    },
+};
 /**
  * Default token decimals for TIP-20 stablecoins (e.g. pathUSD, USDC).
  *

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

@@ -0,0 +1,51 @@
+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;
+/** 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,113 @@
+import { decodeFunctionData, encodeFunctionData, isAddressEqual, } from 'viem';
+import { call, readContract } from 'viem/actions';
+import { Abis, Actions } from 'viem/tempo';
+import * as defaults from './defaults.js';
+const swapAbi = [
+    {
+        inputs: [
+            { name: 'inputToken', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+            { name: 'targetToken', type: 'address' },
+            { name: 'recipient', type: 'address' },
+            { name: 'memo', type: 'bytes32' },
+        ],
+        name: 'swapTo',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+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);
+}
+/** 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: swapAbi,
+                    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: swapAbi, 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/internal/machine-token-session.d.ts

@@ -0,0 +1,88 @@
+import type * as Hex from 'ox/Hex';
+import { type Account, type Address, type Client } from 'viem';
+import * as defaults from './defaults.js';
+type Deployment = (typeof defaults.machineToken)[keyof typeof defaults.machineToken];
+/** Verified machine-token session route. */
+export type Route = {
+    operator: Address;
+    payee: Address;
+    token: Address;
+};
+type Authorization = {
+    channelId: Hex.Hex;
+    cumulativeAmount: bigint;
+};
+/** Returns whether a unified machine-token router is configured on a chain. */
+export declare function isSupported(chainId: number | undefined): boolean;
+/** Matches a session descriptor to the configured router and machine token. */
+export declare function matchDeployment(parameters: {
+    chainId: number | undefined;
+    descriptor: {
+        operator: Address;
+        token: Address;
+    };
+}): Deployment | undefined;
+/** Returns whether an authenticated session challenge permits the machine-token rail. */
+export declare function isEnabledChallenge(challenge: {
+    request: {
+        methodDetails?: unknown;
+    };
+}): boolean;
+/** Resolves the fee token from the payment token and an optional explicit override. */
+export declare function resolveFeeToken(parameters: {
+    chainId: number | undefined;
+    override?: Address | undefined;
+    paymentToken: Address;
+}): Address;
+/**
+ * Resolves the fee tokens accepted for direct-rail sponsored transactions.
+ * Clients released before the fee-token advertisement always pay sponsored
+ * fees in the payment token, so it stays accepted alongside a configured
+ * override. Machine-rail routes post-date the advertisement and pin a single
+ * token via {@link resolveFeeToken}.
+ */
+export declare function allowedSponsoredFeeTokens(parameters: {
+    chainId: number | undefined;
+    override?: Address | undefined;
+    paymentToken: Address;
+}): readonly Address[];
+/** Returns whether an account has enough of a TIP-20 token for an operation. */
+export declare function hasSufficientBalance(client: Client, parameters: {
+    account: Address;
+    amount: bigint;
+    token: Address;
+}): Promise<boolean>;
+/** Signs a cumulative amount in the router-specific authorization domain. */
+export declare function signAuthorization(client: Client, account: Account, parameters: {
+    authorization: Authorization;
+    chainId: number;
+    router: Address;
+}): Promise<Hex.Hex>;
+/** Verifies a cumulative authorization in the router-specific domain. */
+export declare function verifyAuthorization(parameters: {
+    authorization: Authorization;
+    chainId: number;
+    expectedSigner: Address;
+    router: Address;
+    signature: Hex.Hex;
+}): boolean;
+/** Resolves the active virtual payee and verifies its immutable reverse binding. */
+export declare function resolveRoute(client: Client, parameters: {
+    chainId: number;
+    merchant: Address;
+    targetToken: Address;
+}): Promise<Route | undefined>;
+/** Verifies a descriptor against the trusted router and merchant payout binding. */
+export declare function matchRoute(client: Client, parameters: {
+    active?: boolean | undefined;
+    chainId: number;
+    descriptor: {
+        operator: Address;
+        payee: Address;
+        token: Address;
+    };
+    merchant: Address;
+    targetToken: Address;
+}): Promise<Route | undefined>;
+export {};
+//# sourceMappingURL=machine-token-session.d.ts.map