mppx 0.8.15 → 0.8.18

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({
@@ -17,12 +18,6 @@ const chargeContextSchema = z.object({
     autoSwap: z.optional(z.custom()),
     mode: z.optional(z.enum(Methods.chargeModes)),
 });
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getTransferCall(client, parameters) {
-    const call = Actions.token.transfer.call;
-    const result = call.length >= 2 ? call(client, parameters) : call(parameters);
-    return result;
-}
 /**
  * Creates a Tempo charge method intent for usage on the client.
  *
@@ -104,19 +99,20 @@ export function charge(parameters = {}) {
                 },
                 recipient: request.recipient,
             });
-            const transferCalls = transfers.map((transfer) => getTransferCall(client, {
+            const transferCalls = transfers.map((transfer) => Actions.token.transfer.call(client, {
                 amount: BigInt(transfer.amount),
                 ...(transfer.memo && { memo: transfer.memo }),
                 to: transfer.recipient,
                 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 = (() => {
@@ -131,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),
@@ -140,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)
@@ -149,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

@@ -24,8 +24,8 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
     readonly name: "tempo";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 hash: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"hash">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
@@ -36,7 +36,8 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
             }, import("zod/v4/core").$strip>], "type">;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        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>;
@@ -52,31 +53,33 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 recipient: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
             }, import("zod/v4/core").$strip>>>;
             supportedModes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniEnum<{
-                push: "push";
                 pull: "pull";
+                push: "push";
             }>>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
+            amount: string;
             methodDetails?: {
-                supportedModes?: ("push" | "pull")[] | undefined;
+                machineTokenEnabled?: boolean | undefined;
+                chainId?: number | undefined;
+                feePayer?: boolean | undefined;
+                memo?: string | undefined;
                 splits?: {
-                    amount: string;
-                    recipient: `0x${string}`;
                     memo?: string | undefined;
+                    recipient: `0x${string}`;
+                    amount: string;
                 }[] | undefined;
-                memo?: string | undefined;
-                feePayer?: boolean | undefined;
-                chainId?: number | undefined;
+                supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
-            amount: string;
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
+            chainId?: number | undefined;
             currency: string;
             decimals: number;
-            chainId?: number | undefined;
             description?: string | undefined;
             externalId?: string | undefined;
             feePayer?: boolean | undefined;
@@ -84,26 +87,27 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             recipient?: string | undefined;
             splits?: {
                 amount: string;
-                recipient: `0x${string}`;
                 memo?: string | undefined;
+                recipient: `0x${string}`;
             }[] | undefined;
-            supportedModes?: ("push" | "pull")[] | undefined;
+            supportedModes?: ("pull" | "push")[] | undefined;
         }>>;
     };
 }, import("zod/mini").ZodMiniObject<{
     account: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<`0x${string}` | import("../../viem/Account.js").Account | undefined, `0x${string}` | import("../../viem/Account.js").Account | undefined>>;
     autoSwap: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../internal/auto-swap.js").resolve.Value | undefined, import("../internal/auto-swap.js").resolve.Value | undefined>>;
     mode: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniEnum<{
-        push: "push";
         pull: "pull";
+        push: "push";
     }>>;
 }, import("zod/v4/core").$strip>>, import("../../Method.js").Client<{
     readonly name: "tempo";
     readonly intent: "session";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+        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,19 +124,22 @@ 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">;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
             amount: import("zod/mini").ZodMiniString<string>;
             chainId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
             channelId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -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>>;
@@ -151,46 +160,50 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             suggestedDeposit: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             unitType: import("zod/mini").ZodMiniString<string>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: string;
+            recipient?: string | undefined;
+            unitType: string;
+            amount: string;
+            suggestedDeposit?: string | undefined;
             methodDetails: {
-                sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
-                sessionProtocol?: "v1" | "v2" | undefined;
-                operator?: string | undefined;
-                feePayer?: boolean | undefined;
-                chainId?: number | undefined;
-                minVoucherDelta?: string | undefined;
-                channelId?: string | undefined;
                 escrowContract: string | undefined;
+                channelId?: string | undefined;
+                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;
             };
-            suggestedDeposit?: string | undefined;
-            amount: string;
-            currency: string;
-            unitType: string;
-            recipient?: string | undefined;
         }, {
             amount: string;
-            currency: string;
-            decimals: number;
-            unitType: string;
             chainId?: number | undefined;
             channelId?: string | undefined;
+            currency: string;
+            decimals: number;
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
+            feeToken?: string | undefined;
+            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;
             sessionProtocol?: "v1" | "v2" | undefined;
             sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
             suggestedDeposit?: string | undefined;
+            unitType: string;
         }>>;
     };
 }, import("zod/mini").ZodMiniObject<{
     account: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<`0x${string}` | import("../../viem/Account.js").Account | undefined, `0x${string}` | import("../../viem/Account.js").Account | undefined>>;
     autoSwap: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../internal/auto-swap.js").resolve.Value, import("../internal/auto-swap.js").resolve.Value>>;
     action: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniEnum<{
+        close: "close";
         open: "open";
         topUp: "topUp";
         voucher: "voucher";
-        close: "close";
     }>>;
     channelId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<`0x${string}`, `0x${string}`>>;
     cumulativeAmount: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;

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

@@ -17,19 +17,19 @@ export declare function subscription(parameters?: subscription.Parameters): Meth
     readonly name: "tempo";
     readonly intent: "subscription";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniObject<{
                 signature: z.ZodMiniString<string>;
                 type: z.ZodMiniLiteral<"keyAuthorization">;
             }, z.core.$strip>;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             accessKey: z.ZodMiniOptional<z.ZodMiniObject<{
                 accessKeyAddress: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
                 keyType: z.ZodMiniEnum<{
-                    secp256k1: "secp256k1";
                     p256: "p256";
+                    secp256k1: "secp256k1";
                     webAuthn: "webAuthn";
                 }>;
             }, z.core.$strip>>;
@@ -42,8 +42,8 @@ export declare function subscription(parameters?: subscription.Parameters): Meth
                 accessKey: z.ZodMiniOptional<z.ZodMiniObject<{
                     accessKeyAddress: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
                     keyType: z.ZodMiniEnum<{
-                        secp256k1: "secp256k1";
                         p256: "p256";
+                        secp256k1: "secp256k1";
                         webAuthn: "webAuthn";
                     }>;
                 }, z.core.$strip>>;
@@ -51,54 +51,54 @@ export declare function subscription(parameters?: subscription.Parameters): Meth
             }, z.core.$strip>>;
             periodCount: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniBigInt<bigint>, z.ZodMiniCustom<number, number>]>, z.ZodMiniTransform<string, string | number | bigint>>;
             periodUnit: z.ZodMiniEnum<{
-                dev_second: "dev_second";
                 day: "day";
+                dev_second: "dev_second";
                 week: "week";
             }>;
             recipient: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
             subscriptionExpires: z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniCustom<Date, Date>]>, z.ZodMiniTransform<Date, z.DatetimeInput>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            currency: `0x${string}`;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            periodCount: string;
+            periodUnit: "day" | "dev_second" | "week";
+            recipient: `0x${string}`;
+            amount: string;
+            subscriptionExpires: string;
             methodDetails?: {
                 accessKey?: z.infer<z.ZodMiniObject<{
                     accessKeyAddress: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
                     keyType: z.ZodMiniEnum<{
-                        secp256k1: "secp256k1";
                         p256: "p256";
+                        secp256k1: "secp256k1";
                         webAuthn: "webAuthn";
                     }>;
                 }, z.core.$strip>> | undefined;
                 chainId?: number | undefined;
             } | undefined;
-            amount: string;
-            subscriptionExpires: string;
-            currency: `0x${string}`;
-            periodCount: string;
-            periodUnit: "dev_second" | "day" | "week";
-            recipient: `0x${string}`;
-            description?: string | undefined;
-            externalId?: string | undefined;
         }, {
             amount: string;
-            currency: `0x${string}`;
-            decimals: number;
-            periodCount: string;
-            periodUnit: "dev_second" | "day" | "week";
-            recipient: `0x${string}`;
-            subscriptionExpires: Date;
             accessKey?: {
                 accessKeyAddress: `0x${string}`;
-                keyType: "secp256k1" | "p256" | "webAuthn";
+                keyType: "p256" | "secp256k1" | "webAuthn";
             } | undefined;
             chainId?: number | undefined;
+            currency: `0x${string}`;
+            decimals: number;
             description?: string | undefined;
             externalId?: string | undefined;
             methodDetails?: {
                 accessKey?: {
                     accessKeyAddress: `0x${string}`;
-                    keyType: "secp256k1" | "p256" | "webAuthn";
+                    keyType: "p256" | "secp256k1" | "webAuthn";
                 } | undefined;
                 chainId?: number | undefined;
             } | undefined;
+            periodCount: string;
+            periodUnit: "day" | "dev_second" | "week";
+            recipient: `0x${string}`;
+            subscriptionExpires: Date;
         }>>;
     };
 }, z.ZodMiniObject<{

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

@@ -1,3 +1,4 @@
-import type { TempoAddress } from 'ox/tempo';
+import { TempoAddress } from 'ox/tempo';
+/** Returns whether two hex or Tempo-formatted addresses resolve to the same address. */
 export declare function isEqual(a: TempoAddress.Address, b: TempoAddress.Address): boolean;
 //# sourceMappingURL=address.d.ts.map

package/dist/tempo/internal/address.js

@@ -1,4 +1,6 @@
+import { TempoAddress } from 'ox/tempo';
+/** Returns whether two hex or Tempo-formatted addresses resolve to the same address. */
 export function isEqual(a, b) {
-    return a.toLowerCase() === b.toLowerCase();
+    return TempoAddress.resolve(a).toLowerCase() === TempoAddress.resolve(b).toLowerCase();
 }
 //# sourceMappingURL=address.js.map

package/dist/tempo/internal/auto-swap.js

@@ -9,21 +9,6 @@ export const defaultCurrencies = [
     defaults.tokens.pathUsd,
     defaults.tokens.usdc,
 ];
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getBalanceCall(client, parameters) {
-    const call = Actions.token.getBalance.call;
-    return call.length >= 2 ? call(client, parameters) : call(parameters);
-}
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getApproveCall(client, parameters) {
-    const call = Actions.token.approve.call;
-    return call.length >= 2 ? call(client, parameters) : call(parameters);
-}
-// TODO: Remove once the minimum viem version is >=2.54.0, which uses client-first Tempo call builders.
-function getBuyCall(client, parameters) {
-    const call = Actions.dex.buy.call;
-    return call.length >= 2 ? call(client, parameters) : call(parameters);
-}
 /**
  * Finds the optimal swap calls to acquire `amountOut` of `tokenOut`,
  * returning an approve + buy call sequence if a viable route is found.
@@ -35,8 +20,8 @@ export async function findCalls(client, parameters) {
     const { account, amountOut, tokenOut, tokenIn, slippage } = parameters;
     const candidates = tokenIn.filter((t) => !TempoAddress.isEqual(t, tokenOut));
     const balanceResults = await Promise.allSettled([
-        readContract(client, getBalanceCall(client, { account, token: tokenOut })),
-        ...candidates.map((t) => readContract(client, getBalanceCall(client, { account, token: t }))),
+        readContract(client, Actions.token.getBalance.call(client, { account, token: tokenOut })),
+        ...candidates.map((t) => readContract(client, Actions.token.getBalance.call(client, { account, token: t }))),
     ]);
     // If the account already has enough of the target token, no swap needed.
     const targetBalance = balanceResults[0];
@@ -60,12 +45,12 @@ export async function findCalls(client, parameters) {
             if (balance >= quotedAmountIn) {
                 const maxAmountIn = quotedAmountIn + (quotedAmountIn * BigInt(Math.round(slippage * 100))) / bps;
                 return [
-                    getApproveCall(client, {
+                    Actions.token.approve.call(client, {
                         amount: maxAmountIn,
                         spender: Addresses.stablecoinDex,
                         token: tokenIn,
                     }),
-                    getBuyCall(client, {
+                    Actions.dex.buy.call({
                         tokenIn,
                         tokenOut,
                         amountOut,

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

@@ -7,15 +7,26 @@ export type ChainId = ValueOf<typeof chainId>;
 /** Token addresses. */
 export declare const tokens: {
     /** USDC (USDC.e) token address. */
-    readonly usdc: "0x20C000000000000000000000b9537d11c60E8b50";
+    readonly usdc: '0x20C000000000000000000000b9537d11c60E8b50';
     /** pathUSD token address. */
-    readonly pathUsd: "0x20c0000000000000000000000000000000000000";
+    readonly pathUsd: '0x20c0000000000000000000000000000000000000';
 };
 /** Chain ID → default currency. */
 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).
  *
@@ -26,13 +37,13 @@ export declare const currency: {
 export declare const decimals = 6;
 /** Default payment-channel escrow contract addresses per chain. */
 export declare const escrowContract: {
-    readonly 4217: "0x33b901018174DDabE4841042ab76ba85D4e24f25";
-    readonly 42431: "0xe1c4d3dce17bc111181ddf716f75bae49e61a336";
+    readonly 4217: '0x33b901018174DDabE4841042ab76ba85D4e24f25';
+    readonly 42431: '0xe1c4d3dce17bc111181ddf716f75bae49e61a336';
 };
 /** Default RPC URLs for each Tempo chain. */
 export declare const rpcUrl: {
-    readonly 4217: "https://rpc.tempo.xyz";
-    readonly 42431: "https://rpc.moderato.tempo.xyz";
+    readonly 4217: 'https://rpc.tempo.xyz';
+    readonly 42431: 'https://rpc.moderato.tempo.xyz';
 };
 /** Resolves the default currency. */
 export declare function resolveCurrency(parameters: {

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/fee-payer.d.ts

@@ -124,23 +124,23 @@ export declare function prepareSponsoredTransaction(parameters: {
     policy?: Partial<Policy> | undefined;
     transaction: SponsoredTransaction;
 }): {
-    validBefore: any;
-    validAfter?: any;
-    type: "tempo";
-    signature?: any;
-    nonceKey: any;
-    maxPriorityFeePerGas?: any;
-    maxFeePerGas: any;
-    nonce?: any;
-    keyAuthorization?: any;
-    gas: any;
-    from?: any;
-    feeToken?: any;
     accessList: any;
     account: Account;
     calls: any;
     chainId: any;
     feePayer: Account;
+    feeToken?: any;
+    from?: any;
+    gas: any;
+    keyAuthorization?: any;
+    nonce?: any;
+    maxFeePerGas: any;
+    maxPriorityFeePerGas?: any;
+    nonceKey: any;
+    signature?: any;
+    type: 'tempo';
+    validAfter?: any;
+    validBefore: any;
 };
 export declare class FeePayerValidationError extends Error {
     readonly name = "FeePayerValidationError";

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