mppx 0.8.19 → 0.9.1

package/dist/tempo/Tokens.d.ts

@@ -0,0 +1,13 @@
+import { defineToken } from 'viem/tokens';
+/** MACH token metadata and deployed addresses. */
+export declare const mach: defineToken.ReturnType<{
+    readonly addresses: {
+        readonly 4217: "0x20c000000000000000000000f37de3740ADec032";
+        readonly 42431: "0x20c000000000000000000000f37de3740ADec032";
+    };
+    readonly currency: "USD";
+    readonly decimals: 6;
+    readonly name: "MACH";
+    readonly symbol: "MACH";
+}>;
+//# sourceMappingURL=Tokens.d.ts.map

package/dist/tempo/Tokens.js

@@ -0,0 +1,13 @@
+import { defineToken } from 'viem/tokens';
+/** MACH token metadata and deployed addresses. */
+export const mach = defineToken({
+    addresses: {
+        4217: '0x20c000000000000000000000f37de3740ADec032',
+        42431: '0x20c000000000000000000000f37de3740ADec032',
+    },
+    currency: 'USD',
+    decimals: 6,
+    name: 'MACH',
+    symbol: 'MACH',
+});
+//# sourceMappingURL=Tokens.js.map

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,7 +42,6 @@ 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>;
@@ -68,7 +67,6 @@ 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;
@@ -80,7 +78,6 @@ 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,3 +1,4 @@
+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';
@@ -10,9 +11,10 @@ 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 { defaultFeeTokens, resolveFeeToken } from '../internal/fee-token.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()),
@@ -106,13 +108,12 @@ 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 || machineTokenEnabled ? {} : { calls: transferCalls }),
+                    ...(autoSwap ? {} : { calls: transferCalls }),
                 },
             })) ?? defaultAccount;
             const mode = (() => {
@@ -127,15 +128,7 @@ export function charge(parameters = {}) {
                     return preferredMode;
                 return supportedModes[0];
             })();
-            const machineTokenRoute = machineTokenEnabled
-                ? await MachineTokenCharge.findRoute(client, {
-                    account: account.address,
-                    chainId,
-                    currency,
-                    transfers,
-                })
-                : undefined;
-            const swapCalls = !machineTokenRoute && autoSwap
+            const swapCalls = autoSwap
                 ? await AutoSwap.findCalls(client, {
                     account: account.address,
                     amountOut: BigInt(amount),
@@ -144,7 +137,18 @@ export function charge(parameters = {}) {
                     slippage: autoSwap.slippage,
                 })
                 : undefined;
-            const calls = machineTokenRoute?.calls ?? [...(swapCalls ?? []), ...transferCalls];
+            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)
@@ -159,6 +163,7 @@ export function charge(parameters = {}) {
                             await sendTransactionSync(client, {
                                 account,
                                 calls,
+                                ...(feeToken ? { feeToken } : {}),
                                 nonceKey: 'expiring',
                                 validBefore,
                             }),
@@ -166,6 +171,7 @@ export function charge(parameters = {}) {
                     }
                     : await sendCallsSync(client, {
                         account,
+                        ...(feeToken ? { capabilities: { feeToken } } : {}),
                         calls: calls,
                         experimental_fallback: calls.length === 1,
                         forceAtomic: calls.length > 1,
@@ -182,6 +188,7 @@ export function charge(parameters = {}) {
             const prepared = await prepareTransactionRequest(client, {
                 account,
                 calls,
+                ...(feeToken ? { feeToken } : {}),
                 nonceKey: 'expiring',
                 validBefore,
             });

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

@@ -37,7 +37,6 @@ 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>;
@@ -63,7 +62,6 @@ 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;
@@ -75,7 +73,6 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
         }, {
-            machineTokenEnabled?: boolean | undefined;
             amount: string;
             chainId?: number | undefined;
             currency: string;
@@ -107,7 +104,6 @@ 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>;
@@ -124,18 +120,15 @@ 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">;
         };
@@ -148,7 +141,6 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             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>>;
@@ -172,7 +164,6 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
                 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;
@@ -186,7 +177,6 @@ export declare function tempo(parameters?: tempo.Parameters): readonly [import("
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
             feeToken?: string | undefined;
-            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;

package/dist/tempo/index.d.ts

@@ -3,4 +3,5 @@ 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';
 //# sourceMappingURL=index.d.ts.map

package/dist/tempo/index.js

@@ -3,4 +3,5 @@ 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';
 //# sourceMappingURL=index.js.map

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

@@ -1,5 +1,8 @@
 import type { Account, Address } from 'viem';
 import type { Account as TempoAccount } from 'viem/tempo';
+import * as RemoteFeePayer from './remote-fee-payer.js';
+/** Returns whether a value is a viem account. */
+export declare function is(value: unknown): value is Account;
 /** Returns whether an account is a Tempo access-key account. */
 export declare function isAccessKeyAccount(account: Account): account is Account & TempoAccount.AccessKeyAccount;
 /** Returns the address that should authorize direct account signatures. */
@@ -10,15 +13,18 @@ export declare function getAccountSignerAddress(account: Account): Address;
  * Accepts either `account` or `recipient` as the parameter name. When the value
  * is an `Account`, its address is extracted. If `feePayer` is `true`, the
  * account also acts as the fee payer. Alternatively, a separate `Account`
- * can be provided as the fee payer, or a URL string pointing to a fee payer
- * relay service (used with `withFeePayer` transport wrapping).
+ * can be provided as the fee payer, or remote fee-payer configuration (used
+ * with `withFeePayer` transport wrapping).
  *
- * @returns An object with `account`, `feePayer`, `feePayerUrl`, and `recipient`.
+ * @returns Resolved account, local fee payer, remote fee payer, and recipient.
  */
 export declare function resolve(parameters: resolve.Parameters): {
     account: Account | undefined;
     feePayer: Account | undefined;
-    feePayerUrl: string | undefined;
+    remoteFeePayer: Readonly<{
+        headers?: Readonly<Record<string, string>> | undefined;
+        url: string;
+    }> | undefined;
     recipient: Address | undefined;
 };
 export declare namespace resolve {
@@ -26,8 +32,11 @@ export declare namespace resolve {
         recipient?: Address | undefined;
         /** Account or address that performs payment operations / receives payment. */
         account?: Account | Address | undefined;
-        /** When `true`, the account also sponsors fees. An `Account` object or URL string can also be provided as a dedicated fee payer. */
-        feePayer?: Account | string | true | undefined;
+        /**
+         * When `true`, the account also sponsors fees. An `Account` or remote fee-payer
+         * configuration can also be provided. A string is shorthand for its URL.
+         */
+        feePayer?: Account | RemoteFeePayer.Config | string | true | undefined;
     };
 }
 //# sourceMappingURL=account.d.ts.map

package/dist/tempo/internal/account.js

@@ -1,3 +1,8 @@
+import * as RemoteFeePayer from './remote-fee-payer.js';
+/** Returns whether a value is a viem account. */
+export function is(value) {
+    return typeof value === 'object' && value !== null && 'address' in value;
+}
 /** Returns whether an account is a Tempo access-key account. */
 export function isAccessKeyAccount(account) {
     return 'accessKeyAddress' in account;
@@ -12,34 +17,20 @@ export function getAccountSignerAddress(account) {
  * Accepts either `account` or `recipient` as the parameter name. When the value
  * is an `Account`, its address is extracted. If `feePayer` is `true`, the
  * account also acts as the fee payer. Alternatively, a separate `Account`
- * can be provided as the fee payer, or a URL string pointing to a fee payer
- * relay service (used with `withFeePayer` transport wrapping).
+ * can be provided as the fee payer, or remote fee-payer configuration (used
+ * with `withFeePayer` transport wrapping).
  *
- * @returns An object with `account`, `feePayer`, `feePayerUrl`, and `recipient`.
+ * @returns Resolved account, local fee payer, remote fee payer, and recipient.
  */
 export function resolve(parameters) {
-    const account = (() => {
-        if (typeof parameters.account === 'object')
-            return parameters.account;
-        return undefined;
-    })();
-    const recipient = (() => {
-        if (parameters.recipient)
-            return parameters.recipient;
-        if (typeof parameters.account === 'object')
-            return parameters.account.address;
-        return parameters.account;
-    })();
-    const feePayerUrl = typeof parameters.feePayer === 'string' ? parameters.feePayer : undefined;
-    const feePayer = (() => {
-        if (typeof parameters.feePayer === 'string')
-            return undefined;
-        if (typeof parameters.account === 'object' && parameters.feePayer === true)
-            return parameters.account;
-        if (typeof parameters.feePayer === 'object')
-            return parameters.feePayer;
-        return undefined;
-    })();
-    return { account, feePayer, feePayerUrl, recipient: recipient };
+    const account = is(parameters.account) ? parameters.account : undefined;
+    const recipient = parameters.recipient ?? account?.address ?? parameters.account;
+    const remoteFeePayer = RemoteFeePayer.from(parameters.feePayer);
+    const feePayer = parameters.feePayer === true
+        ? account
+        : is(parameters.feePayer)
+            ? parameters.feePayer
+            : undefined;
+    return { account, feePayer, remoteFeePayer, recipient: recipient };
 }
 //# sourceMappingURL=account.js.map

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

@@ -16,17 +16,6 @@ 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,17 +14,6 @@ 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

@@ -24,14 +24,29 @@ type ExpectedTransfer = {
     recipient: TempoAddress.Address;
 };
 /** Returns fee tokens that mppx allows sponsored transactions to charge. */
-export declare function defaultAllowedFeeTokens(chainId: number | undefined): TempoAddress.Address[];
+export declare function defaultAllowedFeeTokens(chainId: number | undefined): `0x${string}`[];
 /** Rejects a sponsored fee token outside the server's allowlist. */
 export declare function assertAllowedFeeToken(transaction: {
     feeToken?: unknown;
 }, allowedFeeTokens: readonly TempoAddress.Address[]): void;
+declare function hostedFeePayerRequest(transaction: SponsoredTransaction): {
+    accessList?: any;
+    calls: any;
+    feePayer: boolean;
+    from: any;
+    gas?: `0x${string}` | undefined;
+    keyAuthorization?: any;
+    maxFeePerGas?: `0x${string}` | undefined;
+    maxPriorityFeePerGas?: `0x${string}` | undefined;
+    nonce: `0x${string}`;
+    nonceKey?: `0x${string}` | undefined;
+    type: string;
+    validAfter?: `0x${string}` | undefined;
+    validBefore?: `0x${string}` | undefined;
+};
 /**
- * Co-signs a sender-signed partial sponsorship envelope using a hosted
- * fee-payer endpoint without letting the endpoint mutate sender-committed
+ * Co-signs a sender-signed partial sponsorship envelope through a hosted
+ * fee-payer transport without letting the endpoint mutate sender-committed
  * transaction fields.
  *
  * @returns The serialized co-signed transaction plus the sponsor's recovered
@@ -44,8 +59,11 @@ export declare function fillHostedFeePayerTransaction(parameters: {
     chainId: number;
     details: Record<string, string>;
     policy?: Partial<Policy> | undefined;
+    request: (args: {
+        method: 'eth_fillTransaction';
+        params: readonly [ReturnType<typeof hostedFeePayerRequest>];
+    }) => Promise<unknown>;
     transaction: SponsoredTransaction;
-    url: string;
 }): Promise<{
     feePayer: `0x${string}`;
     feeToken: TempoAddress.Address;

package/dist/tempo/internal/fee-payer.js

@@ -4,6 +4,7 @@ import { decodeFunctionData, encodeFunctionData, maxUint256, toHex } from 'viem'
 import { Abis, Addresses, Transaction } from 'viem/tempo';
 import * as TempoAddress_internal from './address.js';
 import * as defaults from './defaults.js';
+import { defaultFeeTokens } from './fee-token.js';
 import * as Selectors from './selectors.js';
 /** Returns true if the serialized transaction has a Tempo envelope prefix. */
 export function isTempoTransaction(serialized) {
@@ -58,20 +59,9 @@ const supportedTransactionKeys = new Set([
     ...rejectedTransactionKeys,
     ...rewrittenTransactionKeys,
 ]);
-function pushAllowedFeeToken(tokens, token) {
-    if (!token)
-        return;
-    const normalized = token;
-    if (tokens.some((existing) => TempoAddress_internal.isEqual(existing, normalized)))
-        return;
-    tokens.push(normalized);
-}
 /** Returns fee tokens that mppx allows sponsored transactions to charge. */
 export function defaultAllowedFeeTokens(chainId) {
-    const tokens = [];
-    pushAllowedFeeToken(tokens, defaults.tokens.pathUsd);
-    pushAllowedFeeToken(tokens, defaults.currency[chainId]);
-    return tokens;
+    return defaultFeeTokens(chainId);
 }
 /** Rejects a sponsored fee token outside the server's allowlist. */
 export function assertAllowedFeeToken(transaction, allowedFeeTokens) {
@@ -116,8 +106,8 @@ function hostedFeePayerRequest(transaction) {
     };
 }
 /**
- * Co-signs a sender-signed partial sponsorship envelope using a hosted
- * fee-payer endpoint without letting the endpoint mutate sender-committed
+ * Co-signs a sender-signed partial sponsorship envelope through a hosted
+ * fee-payer transport without letting the endpoint mutate sender-committed
  * transaction fields.
  *
  * @returns The serialized co-signed transaction plus the sponsor's recovered
@@ -125,7 +115,7 @@ function hostedFeePayerRequest(transaction) {
  *   simulate the exact transaction the sponsor broadcasts.
  */
 export async function fillHostedFeePayerTransaction(parameters) {
-    const { allowedFeeTokens, challengeExpires, chainId, details, policy, transaction, url } = parameters;
+    const { allowedFeeTokens, challengeExpires, chainId, details, policy, request, transaction } = parameters;
     assertTransactionPolicy({
         challengeExpires,
         chainId,
@@ -133,22 +123,13 @@ export async function fillHostedFeePayerTransaction(parameters) {
         policy,
         transaction,
     });
-    const response = await fetch(url, {
-        body: JSON.stringify({
-            id: 1,
-            jsonrpc: '2.0',
-            method: 'eth_fillTransaction',
-            params: [hostedFeePayerRequest(transaction)],
-        }, (_key, value) => (typeof value === 'bigint' ? toHex(value) : value)),
-        headers: { 'content-type': 'application/json' },
-        method: 'POST',
-    });
-    const payload = (await response.json().catch(async () => ({
-        error: { message: await response.text() },
-    })));
-    const filled = payload.result?.tx;
-    if (!response.ok || payload.error || !filled?.feePayerSignature)
-        throw new FeePayerValidationError(payload.error?.message ?? 'hosted fee payer failed to sponsor transaction', {});
+    const result = (await request({
+        method: 'eth_fillTransaction',
+        params: [hostedFeePayerRequest(transaction)],
+    }));
+    const filled = result?.tx;
+    if (!filled?.feePayerSignature)
+        throw new FeePayerValidationError('hosted fee payer failed to sponsor transaction', {});
     if (typeof filled.feeToken !== 'string')
         throw new FeePayerValidationError('hosted fee payer did not return a feeToken', {});
     assertAllowedFeeToken({ feeToken: filled.feeToken }, allowedFeeTokens);

package/dist/tempo/internal/fee-token.d.ts

@@ -1,4 +1,6 @@
 import type { Address, Client } from 'viem';
+/** Returns the stablecoins mppx supports for Tempo transaction fees. */
+export declare function defaultFeeTokens(chainId: number | undefined): Address[];
 /**
  * Resolves a funded fee token from account, chain, and caller-supplied preferences.
  *

package/dist/tempo/internal/fee-token.js

@@ -27,6 +27,13 @@ function getChainFeeToken(client) {
     const chainId = client.chain?.id;
     return chainId ? defaults.currency[chainId] : undefined;
 }
+/** Returns the stablecoins mppx supports for Tempo transaction fees. */
+export function defaultFeeTokens(chainId) {
+    const tokens = [];
+    pushUnique(tokens, defaults.tokens.pathUsd);
+    pushUnique(tokens, defaults.currency[chainId]);
+    return tokens;
+}
 /**
  * Resolves a funded fee token from account, chain, and caller-supplied preferences.
  *

package/dist/tempo/internal/remote-fee-payer.d.ts

@@ -0,0 +1,12 @@
+/** Configuration for a remote Tempo fee-payer service. */
+export type Config = Readonly<{
+    headers?: Readonly<Record<string, string>> | undefined;
+    url: string;
+}>;
+/** Returns whether a value is remote fee-payer configuration. */
+export declare function is(value: unknown): value is Config;
+/** Normalizes remote fee-payer string and object inputs. */
+export declare function from(value: unknown): Config | undefined;
+/** Returns a cloned header record while reserving JSON content type for MPPX. */
+export declare function resolveHeaders(config: Config): Record<string, string>;
+//# sourceMappingURL=remote-fee-payer.d.ts.map

package/dist/tempo/internal/remote-fee-payer.js

@@ -0,0 +1,17 @@
+/** Returns whether a value is remote fee-payer configuration. */
+export function is(value) {
+    return (typeof value === 'object' && value !== null && 'url' in value && typeof value.url === 'string');
+}
+/** Normalizes remote fee-payer string and object inputs. */
+export function from(value) {
+    if (typeof value === 'string')
+        return { url: value };
+    if (is(value))
+        return value;
+    return undefined;
+}
+/** Returns a cloned header record while reserving JSON content type for MPPX. */
+export function resolveHeaders(config) {
+    return Object.fromEntries(Object.entries(config.headers ?? {}).filter(([name]) => name.toLowerCase() !== 'content-type'));
+}
+//# sourceMappingURL=remote-fee-payer.js.map

package/dist/tempo/legacy/client/Session.d.ts

@@ -65,7 +65,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
         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>;
@@ -82,18 +81,15 @@ export declare function session(parameters?: session.Parameters): Method.Client<
                 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<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").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<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").ChannelDescriptor>>;
-                refundSignature: z.ZodMiniOptional<z.ZodMiniString<string>>;
                 signature: z.ZodMiniString<string>;
             }, z.core.$strip>], "action">;
         };
@@ -106,7 +102,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             escrowContract: z.ZodMiniOptional<z.ZodMiniString<string>>;
             feePayer: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniCustom<viem_Account, viem_Account>]>, z.ZodMiniTransform<boolean, boolean | viem_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>>;
@@ -130,7 +125,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
                 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;
@@ -144,7 +138,6 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
             feeToken?: string | undefined;
-            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;

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

@@ -45,8 +45,6 @@ export declare namespace charge {
         } | undefined;
     };
     type Parameters = {
-        /** Enables first-party machine-token settlement for supported Tempo charges. */
-        machineTokenEnabled?: boolean | undefined;
         /** Render payment page when Accept header is text/html (e.g. in browsers) */
         html?: boolean | Html.Config | undefined;
         /**
@@ -101,7 +99,6 @@ 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;
         /**