mppx 0.8.19 → 0.9.0

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/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

@@ -29,9 +29,24 @@ export declare function defaultAllowedFeeTokens(chainId: number | undefined): Te
 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

@@ -116,8 +116,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 +125,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 +133,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/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;
         /**