mppx 0.8.15 → 0.8.18

package/dist/tempo/internal/machine-token-charge.js

@@ -0,0 +1,113 @@
+import { decodeFunctionData, encodeFunctionData, isAddressEqual, } from 'viem';
+import { call, readContract } from 'viem/actions';
+import { Abis, Actions } from 'viem/tempo';
+import * as defaults from './defaults.js';
+const swapAbi = [
+    {
+        inputs: [
+            { name: 'inputToken', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+            { name: 'targetToken', type: 'address' },
+            { name: 'recipient', type: 'address' },
+            { name: 'memo', type: 'bytes32' },
+        ],
+        name: 'swapTo',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];
+function getDeployment(chainId) {
+    if (chainId === undefined)
+        return undefined;
+    return defaults.machineToken[chainId];
+}
+/** Returns whether a first-party machine-token charge route is deployed on a chain. */
+export function isSupported(chainId) {
+    return !!getDeployment(chainId);
+}
+/** Resolves the canonical first-party settlement route for a compatible charge. */
+export function getRoute(parameters) {
+    const deployment = getDeployment(parameters.chainId);
+    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
+    if (!deployment || !transfer?.memo)
+        return undefined;
+    const amount = BigInt(transfer.amount);
+    const memo = transfer.memo;
+    return {
+        calls: [
+            {
+                data: encodeFunctionData({
+                    abi: Abis.tip20,
+                    functionName: 'approve',
+                    args: [deployment.swap, amount],
+                }),
+                to: deployment.token,
+            },
+            {
+                data: encodeFunctionData({
+                    abi: swapAbi,
+                    functionName: 'swapTo',
+                    args: [deployment.token, amount, parameters.currency, transfer.recipient, memo],
+                }),
+                to: deployment.swap,
+            },
+        ],
+        settlementSender: deployment.swap,
+        transfers: [{ amount, memo, recipient: transfer.recipient }],
+    };
+}
+/** Builds and simulates the first-party settlement route. */
+export async function findRoute(client, parameters) {
+    const route = getRoute(parameters);
+    if (!route)
+        return undefined;
+    try {
+        const balance = await readContract(client, Actions.token.getBalance.call(client, {
+            account: parameters.account,
+            token: route.calls[0].to,
+        }));
+        if (balance < route.transfers[0].amount)
+            return undefined;
+        await call(client, { account: parameters.account, calls: route.calls });
+        return route;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Matches an exact first-party settlement route. */
+export function matchRoute(parameters) {
+    const transfer = parameters.transfers.length === 1 ? parameters.transfers[0] : undefined;
+    const swap = parameters.calls[1];
+    if (!transfer || parameters.calls.length !== 2 || !swap?.data)
+        return undefined;
+    try {
+        const decoded = decodeFunctionData({ abi: swapAbi, data: swap.data });
+        const route = getRoute({
+            ...parameters,
+            transfers: [{ ...transfer, memo: transfer.memo ?? decoded.args[4] }],
+        });
+        if (!route)
+            return undefined;
+        if (parameters.calls.some((call, index) => {
+            const expected = route.calls[index];
+            return (!call.data ||
+                !call.to ||
+                !expected ||
+                (call.value ?? 0n) !== 0n ||
+                !isAddressEqual(call.to, expected.to) ||
+                call.data.toLowerCase() !== expected.data.toLowerCase());
+        }))
+            return undefined;
+        return route;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Returns the trusted sender that settles the configured charge route on a chain. */
+export function getSettlementSender(chainId) {
+    return getDeployment(chainId)?.swap;
+}
+//# sourceMappingURL=machine-token-charge.js.map

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

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

package/dist/tempo/internal/machine-token-session.js

@@ -0,0 +1,173 @@
+import { SignatureEnvelope } from 'ox/tempo';
+import { hashTypedData, isAddressEqual, parseAbi, zeroAddress, } from 'viem';
+import { readContract, signTypedData } from 'viem/actions';
+import { Actions } from 'viem/tempo';
+import { isAccessKeyAccount } from './account.js';
+import * as defaults from './defaults.js';
+import { parseCanonicalEnvelope, serializeCanonicalEnvelope } from './signature-envelope.js';
+const sessionRouteAbi = parseAbi([
+    'function sessionRouteFor(address merchant,address targetToken) view returns (address routeAddress)',
+    'function sessionRoutes(address routeAddress) view returns (address merchant,address targetToken)',
+]);
+const authorizationTypes = {
+    SessionAuthorization: [
+        { name: 'channelId', type: 'bytes32' },
+        { name: 'cumulativeAmount', type: 'uint96' },
+    ],
+};
+function getDeployment(chainId) {
+    if (chainId === undefined)
+        return undefined;
+    return defaults.machineToken[chainId];
+}
+/** Returns whether a unified machine-token router is configured on a chain. */
+export function isSupported(chainId) {
+    return !!getDeployment(chainId);
+}
+/** Matches a session descriptor to the configured router and machine token. */
+export function matchDeployment(parameters) {
+    const deployment = getDeployment(parameters.chainId);
+    return deployment &&
+        isAddressEqual(parameters.descriptor.operator, deployment.swap) &&
+        isAddressEqual(parameters.descriptor.token, deployment.token)
+        ? deployment
+        : undefined;
+}
+/** Returns whether an authenticated session challenge permits the machine-token rail. */
+export function isEnabledChallenge(challenge) {
+    return (challenge.request.methodDetails
+        ?.machineTokenEnabled === true);
+}
+/** Resolves the fee token from the payment token and an optional explicit override. */
+export function resolveFeeToken(parameters) {
+    if (parameters.override)
+        return parameters.override;
+    const deployment = getDeployment(parameters.chainId);
+    if (deployment && isAddressEqual(parameters.paymentToken, deployment.token))
+        return defaults.tokens.pathUsd;
+    return parameters.paymentToken;
+}
+/**
+ * Resolves the fee tokens accepted for direct-rail sponsored transactions.
+ * Clients released before the fee-token advertisement always pay sponsored
+ * fees in the payment token, so it stays accepted alongside a configured
+ * override. Machine-rail routes post-date the advertisement and pin a single
+ * token via {@link resolveFeeToken}.
+ */
+export function allowedSponsoredFeeTokens(parameters) {
+    const feeToken = resolveFeeToken(parameters);
+    if (isAddressEqual(feeToken, parameters.paymentToken))
+        return [feeToken];
+    return [feeToken, parameters.paymentToken];
+}
+/** Returns whether an account has enough of a TIP-20 token for an operation. */
+export async function hasSufficientBalance(client, parameters) {
+    try {
+        const balance = await readContract(client, Actions.token.getBalance.call(client, {
+            account: parameters.account,
+            token: parameters.token,
+        }));
+        return balance >= parameters.amount;
+    }
+    catch {
+        return false;
+    }
+}
+function authorizationDomain(router, chainId) {
+    return {
+        name: 'MachineUSD Session Router',
+        version: '1',
+        chainId,
+        verifyingContract: router,
+    };
+}
+function hashAuthorization(parameters) {
+    return hashTypedData({
+        domain: authorizationDomain(parameters.router, parameters.chainId),
+        types: authorizationTypes,
+        primaryType: 'SessionAuthorization',
+        message: parameters.authorization,
+    });
+}
+/** Signs a cumulative amount in the router-specific authorization domain. */
+export async function signAuthorization(client, account, parameters) {
+    const signature = isAccessKeyAccount(account)
+        ? await account.sign({
+            hash: hashAuthorization(parameters),
+            raw: true,
+        })
+        : await signTypedData(client, {
+            account,
+            domain: authorizationDomain(parameters.router, parameters.chainId),
+            types: authorizationTypes,
+            primaryType: 'SessionAuthorization',
+            message: parameters.authorization,
+        });
+    return serializeCanonicalEnvelope(signature, 'Machine-token session authorizations');
+}
+/** Verifies a cumulative authorization in the router-specific domain. */
+export function verifyAuthorization(parameters) {
+    try {
+        const envelope = parseCanonicalEnvelope(parameters.signature);
+        if (!envelope)
+            return false;
+        const payload = hashAuthorization(parameters);
+        return SignatureEnvelope.verify(envelope, { address: parameters.expectedSigner, payload });
+    }
+    catch {
+        return false;
+    }
+}
+async function readRoute(client, deployment, parameters) {
+    const payee = parameters.payee ??
+        (await readContract(client, {
+            address: deployment.swap,
+            abi: sessionRouteAbi,
+            functionName: 'sessionRouteFor',
+            args: [parameters.merchant, parameters.targetToken],
+        }));
+    if (isAddressEqual(payee, zeroAddress))
+        return undefined;
+    const [binding, activePayee] = await Promise.all([
+        readContract(client, {
+            address: deployment.swap,
+            abi: sessionRouteAbi,
+            functionName: 'sessionRoutes',
+            args: [payee],
+        }),
+        parameters.active && parameters.payee
+            ? readContract(client, {
+                address: deployment.swap,
+                abi: sessionRouteAbi,
+                functionName: 'sessionRouteFor',
+                args: [parameters.merchant, parameters.targetToken],
+            })
+            : payee,
+    ]);
+    if (isAddressEqual(binding[0], zeroAddress) ||
+        isAddressEqual(binding[1], zeroAddress) ||
+        !isAddressEqual(binding[0], parameters.merchant) ||
+        !isAddressEqual(binding[1], parameters.targetToken) ||
+        !isAddressEqual(activePayee, payee))
+        return undefined;
+    return { operator: deployment.swap, payee, token: deployment.token };
+}
+/** Resolves the active virtual payee and verifies its immutable reverse binding. */
+export async function resolveRoute(client, parameters) {
+    const deployment = getDeployment(parameters.chainId);
+    if (!deployment)
+        return undefined;
+    return readRoute(client, deployment, { ...parameters, active: true });
+}
+/** Verifies a descriptor against the trusted router and merchant payout binding. */
+export async function matchRoute(client, parameters) {
+    const deployment = matchDeployment(parameters);
+    if (!deployment)
+        return undefined;
+    return readRoute(client, deployment, {
+        ...parameters,
+        active: parameters.active !== false,
+        payee: parameters.descriptor.payee,
+    });
+}
+//# sourceMappingURL=machine-token-session.js.map

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

@@ -1,6 +1,6 @@
 import { type Address, type Hex } from 'viem';
 /** EIP-712 primary type for proof credentials. */
-export declare const primaryType: "Proof";
+export declare const primaryType: 'Proof';
 /**
  * EIP-712 typed-data field definitions for Tempo zero-amount proof credentials.
  *
@@ -10,20 +10,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 proof credential. */
 export declare function domain(chainId: number): {
-    readonly name: "MPP";
-    readonly version: "3";
+    readonly name: 'MPP';
+    readonly version: '3';
     readonly chainId: number;
 };
 /**
@@ -56,20 +56,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/internal/signature-envelope.d.ts

@@ -0,0 +1,14 @@
+import { SignatureEnvelope } from 'ox/tempo';
+import type { Hex } from 'viem';
+/**
+ * Canonicalizes a fresh TIP-1020 primitive signature for transport. Keychain
+ * wrappers, multisig signatures, and magic-suffixed encodings are rejected.
+ */
+export declare function serializeCanonicalEnvelope(signature: Hex, subject: string): Hex;
+/**
+ * Parses an incoming signature into a canonical TIP-1020 primitive envelope.
+ * Returns `undefined` for wrapper envelopes and aliased (non-canonical)
+ * encodings, so verified signatures can be replayed on-chain byte-for-byte.
+ */
+export declare function parseCanonicalEnvelope(signature: Hex): SignatureEnvelope.SignatureEnvelope | undefined;
+//# sourceMappingURL=signature-envelope.d.ts.map

package/dist/tempo/internal/signature-envelope.js

@@ -0,0 +1,28 @@
+import { SignatureEnvelope } from 'ox/tempo';
+function isPrimitiveEnvelope(type) {
+    return type === 'secp256k1' || type === 'p256' || type === 'webAuthn';
+}
+/**
+ * Canonicalizes a fresh TIP-1020 primitive signature for transport. Keychain
+ * wrappers, multisig signatures, and magic-suffixed encodings are rejected.
+ */
+export function serializeCanonicalEnvelope(signature, subject) {
+    const envelope = SignatureEnvelope.from(signature);
+    if (!isPrimitiveEnvelope(envelope.type))
+        throw new Error(`${subject} require a TIP-1020 primitive signature; received "${envelope.type}".`);
+    return SignatureEnvelope.serialize(envelope);
+}
+/**
+ * Parses an incoming signature into a canonical TIP-1020 primitive envelope.
+ * Returns `undefined` for wrapper envelopes and aliased (non-canonical)
+ * encodings, so verified signatures can be replayed on-chain byte-for-byte.
+ */
+export function parseCanonicalEnvelope(signature) {
+    const envelope = SignatureEnvelope.from(signature);
+    if (!isPrimitiveEnvelope(envelope.type))
+        return undefined;
+    if (SignatureEnvelope.serialize(envelope).toLowerCase() !== signature.toLowerCase())
+        return undefined;
+    return envelope;
+}
+//# sourceMappingURL=signature-envelope.js.map

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

@@ -29,12 +29,12 @@ export type ChannelEntry = {
 };
 /** Resolves the chain ID embedded in a legacy session challenge. */
 export declare function resolveChainId(challenge: Challenge): number;
-/** Resolves the legacy escrow contract from local override, challenge hint, or defaults. */
+/** Resolves the server-advertised escrow against the client's trust policy. */
 export declare function resolveEscrow(challenge: {
     request: {
         methodDetails?: unknown;
     };
-}, chainId: number, escrowContractOverride?: Address): Address;
+}, chainId: number, escrowContractOverride?: Address, allowCustomEscrow?: boolean): Address;
 /** Serializes a legacy session credential with a payer DID source. */
 export declare function serializeCredential(challenge: Challenge, payload: LegacySessionCredentialPayload, chainId: number, account: viem_Account): string;
 /** Creates a legacy cumulative voucher credential payload. */

package/dist/tempo/legacy/client/ChannelOps.js

@@ -24,15 +24,21 @@ export function resolveChainId(challenge) {
     const md = challenge.request.methodDetails;
     return md?.chainId ?? 0;
 }
-/** Resolves the legacy escrow contract from local override, challenge hint, or defaults. */
-export function resolveEscrow(challenge, chainId, escrowContractOverride) {
+/** Resolves the server-advertised escrow against the client's trust policy. */
+export function resolveEscrow(challenge, chainId, escrowContractOverride, allowCustomEscrow = false) {
     const challengeEscrow = challenge.request.methodDetails
         ?.escrowContract;
     const escrow = escrowContractOverride ??
-        challengeEscrow ??
         defaults.escrowContract[chainId];
-    if (!escrow)
-        throw new Error('No `escrowContract` available. Provide it in parameters or ensure the server challenge includes it.');
+    if (!escrow && !(allowCustomEscrow && challengeEscrow))
+        throw new Error('No trusted `escrowContract` available. Provide it in client parameters or use a supported chain.');
+    if (challengeEscrow &&
+        escrow &&
+        challengeEscrow.toLowerCase() !== escrow.toLowerCase() &&
+        (!allowCustomEscrow || escrowContractOverride !== undefined))
+        throw new Error(`Tempo session escrow ${challengeEscrow} does not match client escrow ${escrow}.`);
+    if (challengeEscrow && (!escrow || challengeEscrow.toLowerCase() !== escrow.toLowerCase()))
+        return challengeEscrow;
     return escrow;
 }
 /** Serializes a legacy session credential with a payer DID source. */

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

@@ -8,10 +8,10 @@ import { type ChannelEntry } from './ChannelOps.js';
 export declare const sessionContextSchema: z.ZodMiniObject<{
     account: z.ZodMiniOptional<z.ZodMiniCustom<`0x${string}` | Account.Account | undefined, `0x${string}` | Account.Account | undefined>>;
     action: z.ZodMiniOptional<z.ZodMiniEnum<{
+        close: "close";
         open: "open";
         topUp: "topUp";
         voucher: "voucher";
-        close: "close";
     }>>;
     channelId: z.ZodMiniOptional<z.ZodMiniString<string>>;
     cumulativeAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -62,9 +62,10 @@ export declare function session(parameters?: session.Parameters): Method.Client<
     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>;
@@ -81,19 +82,22 @@ 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">;
         };
-        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>>;
@@ -101,6 +105,8 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             decimals: z.ZodMiniNumber<number>;
             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>>;
@@ -112,45 +118,49 @@ export declare function session(parameters?: session.Parameters): Method.Client<
             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?: 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;
         }>>;
     };
 }, z.ZodMiniObject<{
     account: z.ZodMiniOptional<z.ZodMiniCustom<`0x${string}` | Account.Account | undefined, `0x${string}` | Account.Account | undefined>>;
     action: z.ZodMiniOptional<z.ZodMiniEnum<{
+        close: "close";
         open: "open";
         topUp: "topUp";
         voucher: "voucher";
-        close: "close";
     }>>;
     channelId: z.ZodMiniOptional<z.ZodMiniString<string>>;
     cumulativeAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
@@ -163,13 +173,15 @@ export declare function session(parameters?: session.Parameters): Method.Client<
 /** Type helpers for the legacy low-level session client method. */
 export declare namespace session {
     type Parameters = Account.getResolver.Parameters & Client.getResolver.Parameters & {
+        /** Accept a noncanonical escrow contract advertised by the server. @default false */
+        allowCustomEscrow?: boolean | undefined;
         /** Account that signs voucher digests. Defaults to `account`; access-key accounts sign raw vouchers as their access-key address. */
         voucherSigner?: viem_Account | undefined;
         /** Token decimals for parsing human-readable amounts (default: 6). */
         decimals?: number | undefined;
         /** Initial deposit amount in human-readable units (e.g. "10" for 10 tokens). When set, the method handles the full channel lifecycle (open, voucher, cumulative tracking) automatically. */
         deposit?: string | undefined;
-        /** Escrow contract address override. Derived from challenge or defaults if not provided. */
+        /** Exact escrow contract address pin. Takes precedence over `allowCustomEscrow`. */
         escrowContract?: Address | undefined;
         /** Maximum deposit in human-readable units (e.g. "10"). Caps the server's `suggestedDeposit`. Enables auto-management like `deposit`. */
         maxDeposit?: string | undefined;