mppx 0.8.15 → 0.8.18

package/dist/tap/client/index.js

@@ -0,0 +1,33 @@
+import * as HttpMessageSignature from '../../attestation/internal/HttpMessageSignature.js';
+import { Constants } from '../Constants.js';
+/**
+ * Creates a TAP request signer.
+ *
+ * The signer emits RFC 9421 HTTP message signatures with TAP's
+ * `agent-browser-auth` or `agent-payer-auth` tag. Pass it to
+ * `Attestation.Client.wrapFetch` so MPPX signs both the initial request and
+ * its automatic paid retry.
+ */
+export function signer(config) {
+    const tag = config.intent === Constants.intents.payment ? Constants.tags.payment : Constants.tags.browse;
+    const expiresIn = config.expiresIn ?? Constants.defaultSignatureLifetime;
+    if (!Number.isInteger(expiresIn) ||
+        expiresIn <= 0 ||
+        expiresIn > Constants.maximumSignatureLifetime)
+        throw new RangeError(`TAP expiresIn must be an integer from 1 to ${Constants.maximumSignatureLifetime}.`);
+    return {
+        protocol: Constants.protocol,
+        sign(request, context) {
+            return HttpMessageSignature.sign(request, {
+                components: Constants.requiredComponents,
+                context,
+                expiresIn,
+                key: config.key,
+                keyId: config.keyId,
+                label: config.label ?? Constants.label,
+                tag,
+            });
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/tap/index.d.ts

@@ -0,0 +1,5 @@
+export * as Client from './client/index.js';
+export * as Server from './server/index.js';
+export * from './Constants.js';
+export * from './Types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tap/index.js

@@ -0,0 +1,5 @@
+export * as Client from './client/index.js';
+export * as Server from './server/index.js';
+export * from './Constants.js';
+export * from './Types.js';
+//# sourceMappingURL=index.js.map

package/dist/tap/server/index.d.ts

@@ -0,0 +1,20 @@
+import type * as Attestation from '../../attestation/Types.js';
+import type * as Store from '../../Store.js';
+import type * as Types from '../Types.js';
+/**
+ * Creates a verifier for TAP agent-recognition signatures.
+ *
+ * TAP verifies trusted agent participation and request integrity. Consumer
+ * recognition and payment-container verification stay protocol-specific and
+ * are intentionally not inferred from this header-only verifier.
+ */
+export declare function verifier(config: verifier.Config): Attestation.Verifier<Types.VerifiedRequest>;
+export declare namespace verifier {
+    type Config = {
+        /** Resolves a TAP-approved public key by its `keyid` and signature algorithm. */
+        keyResolver: Attestation.KeyResolver;
+        /** Atomically consumes each nonce in shared storage for multi-instance deployments. */
+        nonceStore: Store.AtomicStore;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/tap/server/index.js

@@ -0,0 +1,36 @@
+import * as HttpMessageSignature from '../../attestation/internal/HttpMessageSignature.js';
+import { Constants } from '../Constants.js';
+/**
+ * Creates a verifier for TAP agent-recognition signatures.
+ *
+ * TAP verifies trusted agent participation and request integrity. Consumer
+ * recognition and payment-container verification stay protocol-specific and
+ * are intentionally not inferred from this header-only verifier.
+ */
+export function verifier(config) {
+    return {
+        async verify(request) {
+            const result = await HttpMessageSignature.verify(request, {
+                keyResolver: config.keyResolver,
+                maxAge: Constants.maximumSignatureLifetime,
+                nonceNamespace: Constants.protocol,
+                nonceStore: config.nonceStore,
+                requiredComponents: Constants.requiredComponents,
+                tag: [Constants.tags.browse, Constants.tags.payment],
+            });
+            if (result.status !== 'verified')
+                return result;
+            return {
+                status: 'verified',
+                value: {
+                    keyId: result.input.keyId,
+                    nonce: result.input.nonce,
+                    intent: result.input.tag === Constants.tags.payment
+                        ? Constants.intents.payment
+                        : Constants.intents.browse,
+                },
+            };
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/tempo/Attribution.d.ts

@@ -22,7 +22,7 @@
 /** First 4 bytes of keccak256("mpp") — the on-chain MPP tag. */
 export declare const tag: `0x${string}`;
 /** 10 zero bytes representing an anonymous (no clientId) client. */
-export declare const anonymous: "0x00000000000000000000";
+export declare const anonymous: '0x00000000000000000000';
 /**
  * Encodes an MPP attribution memo as a `bytes32` hex string.
  *

package/dist/tempo/Methods.d.ts

@@ -2,14 +2,14 @@ import type { Account } from 'viem';
 import * as z from '../zod.js';
 import type { SessionSnapshot } from './session/client/Runtime.js';
 import type * as PrecompileChannel from './session/precompile/Channel.js';
-export declare const chargeModes: readonly ["push", "pull"];
+export declare const chargeModes: readonly ['push', 'pull'];
 export type ChargeMode = (typeof chargeModes)[number];
 export type SubscriptionPeriodCountInput = string | number | bigint;
 declare const subscriptionAccessKey: 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>;
@@ -22,8 +22,8 @@ export declare const charge: {
     readonly name: "tempo";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
                 hash: z.ZodMiniString<string>;
                 type: z.ZodMiniLiteral<"hash">;
             }, z.core.$strip>, z.ZodMiniObject<{
@@ -34,7 +34,8 @@ export declare const charge: {
                 type: z.ZodMiniLiteral<"proof">;
             }, z.core.$strip>], "type">;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        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>;
@@ -50,31 +51,33 @@ export declare const charge: {
                 recipient: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
             }, z.core.$strip>>>;
             supportedModes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniEnum<{
-                push: "push";
                 pull: "pull";
+                push: "push";
             }>>>;
         }, z.core.$strip>, z.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;
@@ -82,10 +85,10 @@ export declare const charge: {
             recipient?: string | undefined;
             splits?: {
                 amount: string;
-                recipient: `0x${string}`;
                 memo?: string | undefined;
+                recipient: `0x${string}`;
             }[] | undefined;
-            supportedModes?: ("push" | "pull")[] | undefined;
+            supportedModes?: ("pull" | "push")[] | undefined;
         }>>;
     };
 };
@@ -99,9 +102,10 @@ export declare const session: {
     readonly name: "tempo";
     readonly intent: "session";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+        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,19 +122,22 @@ 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">;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        request: z.ZodMiniPipe<z.ZodMiniObject<{
             amount: z.ZodMiniString<string>;
             chainId: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
             channelId: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -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>>;
@@ -149,36 +158,40 @@ export declare const session: {
             suggestedDeposit: z.ZodMiniOptional<z.ZodMiniString<string>>;
             unitType: z.ZodMiniString<string>;
         }, z.core.$strip>, z.ZodMiniTransform<{
+            currency: string;
+            recipient?: string | undefined;
+            unitType: string;
+            amount: string;
+            suggestedDeposit?: string | undefined;
             methodDetails: {
-                sessionSnapshot?: 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?: 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?: SessionSnapshot | undefined;
             suggestedDeposit?: string | undefined;
+            unitType: string;
         }>>;
     };
 };
@@ -191,19 +204,19 @@ export declare const subscription: {
     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>>;
@@ -216,8 +229,8 @@ export declare const subscription: {
                 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>>;
@@ -225,47 +238,47 @@ export declare const subscription: {
             }, 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<typeof subscriptionAccessKey> | 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;
         }>>;
     };
 };

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

@@ -9,20 +9,20 @@ export declare const primaryType: "Proof";
  */
 export declare const types: {
     readonly Proof: readonly [{
-        readonly name: "account";
-        readonly type: "address";
+        readonly name: 'account';
+        readonly type: 'address';
     }, {
-        readonly name: "challengeId";
-        readonly type: "string";
+        readonly name: 'challengeId';
+        readonly type: 'string';
     }, {
-        readonly name: "realm";
-        readonly type: "string";
+        readonly name: 'realm';
+        readonly type: 'string';
     }];
 };
 /** Constructs the EIP-712 domain for a Tempo proof credential. */
 export declare function domain(chainId: number): {
-    readonly name: "MPP";
-    readonly version: "3";
+    readonly name: 'MPP';
+    readonly version: '3';
     readonly chainId: number;
 };
 /**
@@ -53,20 +53,20 @@ export declare function typedData(parameters: {
     realm: string;
 }): {
     readonly domain: {
-        readonly name: "MPP";
-        readonly version: "3";
+        readonly name: 'MPP';
+        readonly version: '3';
         readonly chainId: number;
     };
     readonly types: {
         readonly Proof: readonly [{
-            readonly name: "account";
-            readonly type: "address";
+            readonly name: 'account';
+            readonly type: 'address';
         }, {
-            readonly name: "challengeId";
-            readonly type: "string";
+            readonly name: 'challengeId';
+            readonly type: 'string';
         }, {
-            readonly name: "realm";
-            readonly type: "string";
+            readonly name: 'realm';
+            readonly type: 'string';
         }];
     };
     readonly primaryType: "Proof";

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

@@ -29,8 +29,8 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
     readonly name: "tempo";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+        credential: {
+            payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
                 hash: z.ZodMiniString<string>;
                 type: z.ZodMiniLiteral<"hash">;
             }, z.core.$strip>, z.ZodMiniObject<{
@@ -41,7 +41,8 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
                 type: z.ZodMiniLiteral<"proof">;
             }, z.core.$strip>], "type">;
         };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
+        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>;
@@ -57,31 +58,33 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
                 recipient: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<`0x${string}`, string>>;
             }, z.core.$strip>>>;
             supportedModes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniEnum<{
-                push: "push";
                 pull: "pull";
+                push: "push";
             }>>>;
         }, z.core.$strip>, z.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;
@@ -89,18 +92,18 @@ export declare function charge(parameters?: charge.Parameters): Method.Client<{
             recipient?: string | undefined;
             splits?: {
                 amount: string;
-                recipient: `0x${string}`;
                 memo?: string | undefined;
+                recipient: `0x${string}`;
             }[] | undefined;
-            supportedModes?: ("push" | "pull")[] | undefined;
+            supportedModes?: ("pull" | "push")[] | undefined;
         }>>;
     };
 }, z.ZodMiniObject<{
     account: z.ZodMiniOptional<z.ZodMiniCustom<`0x${string}` | Account.Account | undefined, `0x${string}` | Account.Account | undefined>>;
     autoSwap: z.ZodMiniOptional<z.ZodMiniCustom<AutoSwap.resolve.Value | undefined, AutoSwap.resolve.Value | undefined>>;
     mode: z.ZodMiniOptional<z.ZodMiniEnum<{
-        push: "push";
         pull: "pull";
+        push: "push";
     }>>;
 }, z.core.$strip>>;
 export declare namespace charge {