mppx 0.17.3 → 0.17.4

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

@@ -0,0 +1,79 @@
+import { type Address, type Client, type Hex, type TransactionReceipt } from 'viem';
+/** Default time a payer waits for a Zone withdrawal to settle on Tempo. */
+export declare const defaultSettlementTimeoutMs = 60000;
+/** A withdrawal as `ZonePortal.processWithdrawals` receives it on Tempo. */
+export type Withdrawal = {
+    token: Address;
+    senderTag: Hex;
+    to: Address;
+    amount: bigint;
+    memo: Hex;
+    gasLimit: bigint;
+    fallbackNonce: bigint;
+    callbackData: Hex;
+    encryptedSender: Hex;
+};
+/** A `ZonePortal.WithdrawalProcessed` event. */
+export type ProcessedEvent = {
+    to: Address;
+    senderTag: Hex;
+    token: Address;
+    amount: bigint;
+    callbackSuccess: boolean;
+};
+/** Zones a challenge accepts: a list of Zone IDs, or `true` for any Zone. */
+export type Accepted = readonly number[] | true;
+/** Returns whether a value is a valid Zone ID: a positive integer below the Zone chain ID ranges. */
+export declare function isId(zoneId: number): boolean;
+/** Returns whether a challenge's `zones` accepts withdrawals from a Zone. */
+export declare function isAccepted(zones: Accepted | undefined, zoneId: number): boolean;
+/** Returns the Tempo portal address of a Zone. */
+export declare function portalAddress(zoneId: number): Address;
+/**
+ * Derives a Zone ID from a Zone chain ID.
+ *
+ * Zones on Tempo mainnet and Moderato use reserved bases (`421700000` and
+ * `1424310000`). Zones on any other parent chain use `(parentChainId << 32) | zoneId`.
+ */
+export declare function idFromChainId(chainId: number): number;
+/**
+ * Derives the parent Tempo chain ID of a Zone chain ID, or `undefined` when
+ * the chain ID doesn't follow a known Zone scheme.
+ */
+export declare function parentChainIdFromChainId(chainId: number): number | undefined;
+/**
+ * Derives a withdrawal's sender tag, which identifies it in the
+ * `WithdrawalProcessed` event on Tempo.
+ */
+export declare function senderTag(parameters: {
+    fallbackNonce: bigint;
+    sender: Address;
+    transactionHash: Hex;
+}): Hex;
+/** Returns the `WithdrawalProcessed` event a portal emitted for a sender tag. */
+export declare function findProcessedEvent(receipt: Pick<TransactionReceipt, 'logs'>, parameters: {
+    portal: Address;
+    senderTag: Hex;
+}): ProcessedEvent | undefined;
+/**
+ * Finds the withdrawal for a sender tag in the calldata of a settlement
+ * transaction's top-level `processWithdrawals` calls to the portal.
+ */
+export declare function findWithdrawal(calls: readonly {
+    to?: Address | null | undefined;
+    data?: Hex | undefined;
+}[], parameters: {
+    portal: Address;
+    senderTag: Hex;
+}): Withdrawal | undefined;
+/**
+ * Waits until a portal emits `WithdrawalProcessed` for a sender tag and
+ * returns the Tempo transaction hash that settled it.
+ */
+export declare function waitForSettlement(client: Client, parameters: {
+    portal: Address;
+    senderTag: Hex;
+    to?: Address | undefined;
+    timeoutMs?: number | undefined;
+}): Promise<Hex>;
+//# sourceMappingURL=zone.d.ts.map

package/dist/tempo/internal/zone.js

@@ -0,0 +1,133 @@
+import { AbiParameters, Hash } from 'ox';
+import { decodeFunctionData, getAbiItem, parseEventLogs, } from 'viem';
+import { getBlockNumber, getLogs } from 'viem/actions';
+import { Abis, Addresses } from 'viem/tempo';
+import * as TempoAddress from './address.js';
+/** Default time a payer waits for a Zone withdrawal to settle on Tempo. */
+export const defaultSettlementTimeoutMs = 60_000;
+/** Number of Tempo blocks searched back for a settled Zone withdrawal. */
+const lookbackBlocks = 7200n;
+/** Time between polls for a settled Zone withdrawal. */
+const pollingIntervalMs = 500;
+const withdrawalProcessed = getAbiItem({ abi: Abis.zonePortal, name: 'WithdrawalProcessed' });
+/**
+ * Zone IDs from here up read as Zone chain IDs in viem's portal lookup, which
+ * would map them to another Zone's portal.
+ */
+const maxIdExclusive = 421_700_000;
+/** Returns whether a value is a valid Zone ID: a positive integer below the Zone chain ID ranges. */
+export function isId(zoneId) {
+    return Number.isInteger(zoneId) && zoneId > 0 && zoneId < maxIdExclusive;
+}
+/** Returns whether a challenge's `zones` accepts withdrawals from a Zone. */
+export function isAccepted(zones, zoneId) {
+    if (!isId(zoneId))
+        return false;
+    return zones === true || (zones?.includes(zoneId) ?? false);
+}
+/** Returns the Tempo portal address of a Zone. */
+export function portalAddress(zoneId) {
+    return Addresses.zonePortal(zoneId);
+}
+/**
+ * Derives a Zone ID from a Zone chain ID.
+ *
+ * Zones on Tempo mainnet and Moderato use reserved bases (`421700000` and
+ * `1424310000`). Zones on any other parent chain use `(parentChainId << 32) | zoneId`.
+ */
+export function idFromChainId(chainId) {
+    if (chainId >= 2 ** 32)
+        return chainId % 2 ** 32;
+    if (chainId > 1_424_310_000 && chainId < 1_424_320_000)
+        return chainId - 1_424_310_000;
+    if (chainId > 421_700_000 && chainId < 421_710_000)
+        return chainId - 421_700_000;
+    throw new Error(`Cannot derive a Zone ID from chain ID ${chainId}. Pass \`zoneId\`.`);
+}
+/**
+ * Derives the parent Tempo chain ID of a Zone chain ID, or `undefined` when
+ * the chain ID doesn't follow a known Zone scheme.
+ */
+export function parentChainIdFromChainId(chainId) {
+    if (chainId >= 2 ** 32)
+        return Math.floor(chainId / 2 ** 32);
+    if (chainId > 1_424_310_000 && chainId < 1_424_320_000)
+        return 42_431;
+    if (chainId > 421_700_000 && chainId < 421_710_000)
+        return 4_217;
+    return undefined;
+}
+/**
+ * Derives a withdrawal's sender tag, which identifies it in the
+ * `WithdrawalProcessed` event on Tempo.
+ */
+export function senderTag(parameters) {
+    return Hash.keccak256(AbiParameters.encodePacked(['address', 'bytes32', 'uint64'], [parameters.sender, parameters.transactionHash, parameters.fallbackNonce]));
+}
+/** Returns the `WithdrawalProcessed` event a portal emitted for a sender tag. */
+export function findProcessedEvent(receipt, parameters) {
+    const logs = parseEventLogs({ abi: [withdrawalProcessed], logs: receipt.logs });
+    const log = logs.find((log) => TempoAddress.isEqual(log.address, parameters.portal) &&
+        log.args.senderTag.toLowerCase() === parameters.senderTag.toLowerCase());
+    return log?.args;
+}
+/**
+ * Finds the withdrawal for a sender tag in the calldata of a settlement
+ * transaction's top-level `processWithdrawals` calls to the portal.
+ */
+export function findWithdrawal(calls, parameters) {
+    for (const call of calls) {
+        if (!call.to || !call.data || !TempoAddress.isEqual(call.to, parameters.portal))
+            continue;
+        let decoded;
+        try {
+            decoded = decodeFunctionData({ abi: Abis.zonePortal, data: call.data });
+        }
+        catch {
+            continue;
+        }
+        if (decoded.functionName !== 'processWithdrawals')
+            continue;
+        const [withdrawals] = decoded.args;
+        const withdrawal = withdrawals.find((withdrawal) => withdrawal.senderTag.toLowerCase() === parameters.senderTag.toLowerCase());
+        if (withdrawal)
+            return withdrawal;
+    }
+    return undefined;
+}
+/**
+ * Waits until a portal emits `WithdrawalProcessed` for a sender tag and
+ * returns the Tempo transaction hash that settled it.
+ */
+export async function waitForSettlement(client, parameters) {
+    const { timeoutMs = defaultSettlementTimeoutMs } = parameters;
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0)
+        throw new Error('Zone settlement timeout must be a finite, non-negative number.');
+    let latest = await getBlockNumber(client, { cacheTime: 0 });
+    // Scan the lookback window once, then only blocks added since the previous poll.
+    let fromBlock = latest > lookbackBlocks ? latest - lookbackBlocks : 0n;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        if (fromBlock <= latest) {
+            const logs = await getLogs(client, {
+                address: parameters.portal,
+                event: withdrawalProcessed,
+                args: {
+                    senderTag: parameters.senderTag,
+                    ...(parameters.to ? { to: parameters.to } : {}),
+                },
+                fromBlock,
+                toBlock: latest,
+            });
+            const hash = logs[0]?.transactionHash;
+            if (hash)
+                return hash;
+            fromBlock = latest + 1n;
+        }
+        if (Date.now() + pollingIntervalMs > deadline)
+            throw new Error(`Zone withdrawal ${parameters.senderTag} did not settle on Tempo within ${timeoutMs}ms.`);
+        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+        latest = await getBlockNumber(client, { cacheTime: 0 });
+    }
+}
+//# sourceMappingURL=zone.js.map

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

@@ -61,8 +61,10 @@ export declare namespace charge {
          * two thirds of this budget. If it fails with an unknown outcome (e.g. a
          * timeout, a lost connection, or "already known"), mppx polls for the
          * receipt until the deadline, or until 2 seconds after the transaction's
-         * `validBefore` followed by one final lookup, before surfacing the broadcast
-         * error. Definitive rejections fail immediately.
+         * `validBefore` followed by one final lookup, before throwing
+         * `Errors.BroadcastOutcomeUnknownError` with the transaction hash and
+         * `validBefore`, and the broadcast error as `cause`. Definitive rejections
+         * fail immediately with the RPC error.
          * @default 30_000
          */
         confirmationTimeoutMs?: number | undefined;
@@ -143,7 +145,9 @@ export declare namespace charge {
          * report `status: 'success'` based on simulation alone — if the
          * transaction reverts on-chain after broadcast (e.g. due to a state
          * change between simulation and inclusion), the receipt will not reflect
-         * the failure.
+         * the failure. An ambiguous broadcast failure (a timeout, a lost
+         * connection, a 5xx) throws `Errors.BroadcastOutcomeUnknownError` without
+         * polling for a receipt.
          */
         waitForConfirmation?: boolean | undefined;
     } & Client.getResolver.Parameters & Account.resolve.Parameters & Defaults & Method.ComposableHooks<typeof Methods.charge>;

package/dist/tempo/server/Charge.js

@@ -3,7 +3,7 @@ import { decodeFunctionData, formatUnits, keccak256, parseEventLogs, WaitForTran
 import { getTransaction, getTransactionReceipt, sendRawTransaction, sendRawTransactionSync, signTransaction, verifyTypedData, waitForTransactionReceipt, call as viem_call, } from 'viem/actions';
 import { Abis, Actions, Transaction } from 'viem/tempo';
 import { tempo as tempo_chain } from 'viem/tempo/chains';
-import { CredentialReplayedError, PaymentError, VerificationFailedError } from '../../Errors.js';
+import { BroadcastOutcomeUnknownError, CredentialReplayedError, PaymentError, VerificationFailedError, } from '../../Errors.js';
 import * as Expires from '../../Expires.js';
 import * as Method from '../../Method.js';
 import * as Store from '../../Store.js';
@@ -18,6 +18,7 @@ import { resolveFeeToken } from '../internal/fee-token.js';
 import * as MachineTokenCharge from '../internal/machine-token-charge.js';
 import * as Proof from '../internal/proof.js';
 import * as Selectors from '../internal/selectors.js';
+import * as Zone from '../internal/zone.js';
 import * as Methods from '../Methods.js';
 import { fallbackStore } from './internal/fallback-store.js';
 import * as Relay from './Relay.js';
@@ -33,7 +34,7 @@ import * as SponsorBudget from './SponsorBudget.js';
  * ```
  */
 export function charge(parameters = {}) {
-    const { machineTokenEnabled, allowedFeeTokens: configuredAllowedFeeTokens, amount, confirmationTimeoutMs = 30_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, } = parameters;
+    const { machineTokenEnabled, allowedFeeTokens: configuredAllowedFeeTokens, amount, confirmationTimeoutMs = 30_000, currency = defaults.resolveCurrency(parameters), decimals = defaults.decimals, description, externalId, feeToken: configuredFeeToken, feePayerPolicy, html, relay, sponsorBudget, splits, supportedModes, validateSender, waitForConfirmation = true, zones, } = parameters;
     if (configuredAllowedFeeTokens?.length === 0)
         throw new Error('`allowedFeeTokens` must contain at least one token.');
     const storeKeyPrefix = parameters.storeKeyPrefix ?? '';
@@ -187,6 +188,55 @@ export function charge(parameters = {}) {
         const payer = payers.size === 1 ? [...payers][0] : undefined;
         return { payer, receipt, sender, transfers };
     }
+    /**
+     * Validates a payment that a Zone withdrawal settled on Tempo: the portal's
+     * `WithdrawalProcessed` event pays the recipient, and the withdrawal's memo in
+     * the `processWithdrawals` calldata binds it to this challenge.
+     */
+    async function validateZoneCredential(payload, context) {
+        const { amount, challenge, client, currency, methodDetails, recipient, supportedModes } = context;
+        if (supportedModes && !supportedModes.includes('push'))
+            throw new MismatchError('Zone credentials are not supported for this challenge.', {});
+        if (!Zone.isAccepted(methodDetails?.zones, payload.zoneId))
+            throw new MismatchError('Zone is not accepted for this challenge.', {
+                zoneId: String(payload.zoneId),
+            });
+        if (methodDetails?.splits)
+            throw new MismatchError('Zone credentials do not support split payments.', {});
+        const portal = Zone.portalAddress(payload.zoneId);
+        const senderTag = payload.senderTag;
+        const hash = payload.hash;
+        const receipt = await getTransactionReceipt(client, { hash });
+        if (receipt.status !== 'success')
+            throw new MismatchError('Payment verification failed: settlement transaction reverted.', {
+                hash,
+            });
+        const event = Zone.findProcessedEvent(receipt, { portal, senderTag });
+        if (!event)
+            throw new MismatchError('Payment verification failed: Zone withdrawal not settled.', {
+                senderTag,
+            });
+        if (!event.callbackSuccess)
+            throw new MismatchError('Payment verification failed: Zone withdrawal bounced.', {
+                senderTag,
+            });
+        // The event has no memo, so the calldata's withdrawal shows what was paid and for which challenge.
+        const transaction = await getTransaction(client, { hash });
+        const calls = transaction.calls ??
+            (transaction.to ? [{ to: transaction.to, data: transaction.input }] : []);
+        const withdrawal = Zone.findWithdrawal(calls, { portal, senderTag });
+        if (!withdrawal ||
+            withdrawal.gasLimit !== 0n ||
+            !TempoAddress.isEqual(withdrawal.to, recipient) ||
+            !TempoAddress.isEqual(withdrawal.token, currency) ||
+            withdrawal.amount.toString() !== amount)
+            throw new MismatchError('Payment verification failed: Zone withdrawal not found.', {
+                senderTag,
+            });
+        if (!isChallengeBound([withdrawal.memo], { challengeId: challenge.id, realm: challenge.realm }))
+            throw new CredentialReplayedError({ reason: 'memo is not bound to this challenge' });
+        return { hash, portal, receipt, senderTag };
+    }
     async function validateProofCredential(credential, payload, context) {
         const { chainId, challenge, client, isZeroAmount } = context;
         if (!isZeroAmount)
@@ -282,6 +332,18 @@ export function charge(parameters = {}) {
                     type: 'proof',
                 };
             }
+            case 'zone': {
+                const { hash, portal, receipt, senderTag } = await validateZoneCredential(context.payload, context);
+                return {
+                    details: { mode: 'push' },
+                    hash,
+                    payer: undefined,
+                    portal,
+                    receipt,
+                    senderTag,
+                    type: 'zone',
+                };
+            }
             case 'transaction': {
                 const { fundingCurrency, isFeePayerTx, serializedTransaction, settlementSenders, transaction, transfers, } = await validateTransactionCredential(credential, context.payload, request, context);
                 return {
@@ -316,6 +378,7 @@ export function charge(parameters = {}) {
             recipient,
             splits,
             supportedModes,
+            zones,
         },
         stableBinding: chargeBinding,
         html: html
@@ -450,6 +513,15 @@ export function charge(parameters = {}) {
                     }
                     return toReceipt(receipt.transactionHash, fundingCurrency);
                 }
+                case 'zone': {
+                    const { portal, receipt, senderTag } = validated;
+                    if (!(await tryClaimZoneWithdrawal(store, portal, senderTag, replayExpires))) {
+                        throw new CredentialReplayedError({
+                            reason: 'Zone withdrawal has already been used',
+                        });
+                    }
+                    return toReceipt(receipt.transactionHash);
+                }
                 case 'proof': {
                     if (proofStore && !(await tryClaimProof(proofStore, challenge.id, replayExpires))) {
                         throw new CredentialReplayedError({
@@ -639,7 +711,11 @@ export function charge(parameters = {}) {
                                 if (!recovered && validUntil < deadline)
                                     recovered = await withDeadline(getTransactionReceipt(client, { hash: finalHash }), Math.max(deadline, Date.now() + client.pollingInterval), broadcastError).catch(() => undefined);
                                 if (!recovered)
-                                    throw broadcastError;
+                                    throw new BroadcastOutcomeUnknownError({
+                                        cause: broadcastError,
+                                        transactionHash: finalHash,
+                                        validBefore: transaction.validBefore,
+                                    });
                                 receipt = recovered;
                             }
                             if (reservation)
@@ -663,8 +739,18 @@ export function charge(parameters = {}) {
                         // Optimistic path: broadcast without waiting for confirmation
                         // (simulation above already ran). The returned receipt assumes
                         // success — callers opt in via waitForConfirmation: false.
+                        const transactionHash = finalHash;
                         const reference = await sendRawTransaction(client, {
                             serializedTransaction: serializedTransaction_final,
+                        }).catch((broadcastError) => {
+                            // Without a receipt wait, an ambiguous failure leaves the outcome to the caller.
+                            if (!isAmbiguousBroadcastError(broadcastError))
+                                throw broadcastError;
+                            throw new BroadcastOutcomeUnknownError({
+                                cause: broadcastError,
+                                transactionHash,
+                                validBefore: transaction.validBefore,
+                            });
                         });
                         if (reference.toLowerCase() !== finalHash.toLowerCase())
                             throw new VerificationFailedError({
@@ -711,7 +797,7 @@ function chargeBinding(request) {
     // Exhaustively destructure so new charge request fields require an explicit binding decision.
     const { amount, currency, description, externalId, methodDetails, recipient, ...requestRest } = request;
     requestRest;
-    const { chainId, feePayer, machineTokenEnabled, splits, supportedModes, ...methodDetailsRest } = methodDetails ?? {};
+    const { chainId, feePayer, machineTokenEnabled, splits, supportedModes, zones, ...methodDetailsRest } = methodDetails ?? {};
     methodDetailsRest;
     void feePayer;
     return {
@@ -724,6 +810,7 @@ function chargeBinding(request) {
         recipient,
         splits,
         supportedModes,
+        zones,
     };
 }
 function getExpectedTransfers(parameters) {
@@ -953,6 +1040,13 @@ function getHashStoreKey(hash) {
 function getProofStoreKey(challengeId) {
     return `mppx:charge:proof:${challengeId}`;
 }
+/** @internal */
+function getZoneWithdrawalStoreKey(portal, senderTag) {
+    return `mppx:charge:zone:${portal.toLowerCase()}:${senderTag.toLowerCase()}`;
+}
+async function tryClaimZoneWithdrawal(store, portal, senderTag, expires) {
+    return Store.tryClaim(store, getZoneWithdrawalStoreKey(portal, senderTag), expires);
+}
 async function tryClaimHash(store, hash, expires) {
     return Store.tryClaim(store, getHashStoreKey(hash), expires);
 }

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

@@ -51,6 +51,11 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+                hash: import("zod/mini").ZodMiniString<string>;
+                senderTag: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"zone">;
+                zoneId: import("zod/mini").ZodMiniNumber<number>;
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
@@ -73,6 +78,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 pull: "pull";
                 push: "push";
             }>>>;
+            zones: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniLiteral<true>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNumber<number>>]>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
             currency: string;
             description?: string | undefined;
@@ -89,6 +95,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                     amount: string;
                 }[] | undefined;
                 supportedModes?: ("pull" | "push")[] | undefined;
+                zones?: true | number[] | undefined;
             } | undefined;
         }, {
             machineTokenEnabled?: boolean | undefined;
@@ -107,6 +114,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 recipient: `0x${string}`;
             }[] | undefined;
             supportedModes?: ("pull" | "push")[] | undefined;
+            zones?: true | number[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<NoExtraKeys<parameters, tempo.Parameters>>, undefined, {}, string | undefined>, import("../../Method.js").Server<{
@@ -213,6 +221,11 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+                hash: import("zod/mini").ZodMiniString<string>;
+                senderTag: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"zone">;
+                zoneId: import("zod/mini").ZodMiniNumber<number>;
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
@@ -235,6 +248,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 pull: "pull";
                 push: "push";
             }>>>;
+            zones: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniLiteral<true>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNumber<number>>]>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
             currency: string;
             description?: string | undefined;
@@ -251,6 +265,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                     amount: string;
                 }[] | undefined;
                 supportedModes?: ("pull" | "push")[] | undefined;
+                zones?: true | number[] | undefined;
             } | undefined;
         }, {
             machineTokenEnabled?: boolean | undefined;
@@ -269,6 +284,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 recipient: `0x${string}`;
             }[] | undefined;
             supportedModes?: ("pull" | "push")[] | undefined;
+            zones?: true | number[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<Omit<parameters, "chainId" | "currencies" | "currency" | "decimals"> & {
@@ -2323,6 +2339,11 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+                hash: import("zod/mini").ZodMiniString<string>;
+                senderTag: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"zone">;
+                zoneId: import("zod/mini").ZodMiniNumber<number>;
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
@@ -2345,6 +2366,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 pull: "pull";
                 push: "push";
             }>>>;
+            zones: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniLiteral<true>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNumber<number>>]>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
             currency: string;
             description?: string | undefined;
@@ -2361,6 +2383,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                     amount: string;
                 }[] | undefined;
                 supportedModes?: ("pull" | "push")[] | undefined;
+                zones?: true | number[] | undefined;
             } | undefined;
         }, {
             machineTokenEnabled?: boolean | undefined;
@@ -2379,6 +2402,7 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 recipient: `0x${string}`;
             }[] | undefined;
             supportedModes?: ("pull" | "push")[] | undefined;
+            zones?: true | number[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<Omit<parameters, "chainId" | "currencies" | "currency" | "decimals"> & {
@@ -2467,6 +2491,11 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+                hash: import("zod/mini").ZodMiniString<string>;
+                senderTag: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"zone">;
+                zoneId: import("zod/mini").ZodMiniNumber<number>;
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
@@ -2489,6 +2518,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                 pull: "pull";
                 push: "push";
             }>>>;
+            zones: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniLiteral<true>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNumber<number>>]>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
             currency: string;
             description?: string | undefined;
@@ -2505,6 +2535,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                     amount: string;
                 }[] | undefined;
                 supportedModes?: ("pull" | "push")[] | undefined;
+                zones?: true | number[] | undefined;
             } | undefined;
         }, {
             machineTokenEnabled?: boolean | undefined;
@@ -2523,6 +2554,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                 recipient: `0x${string}`;
             }[] | undefined;
             supportedModes?: ("pull" | "push")[] | undefined;
+            zones?: true | number[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<Omit<parameters, "chainId" | "currencies" | "currency" | "decimals"> & {
@@ -2543,6 +2575,11 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
+            }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
+                hash: import("zod/mini").ZodMiniString<string>;
+                senderTag: import("zod/mini").ZodMiniString<string>;
+                type: import("zod/mini").ZodMiniLiteral<"zone">;
+                zoneId: import("zod/mini").ZodMiniNumber<number>;
             }, import("zod/v4/core").$strip>], "type">;
         };
         request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
@@ -2565,6 +2602,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                 pull: "pull";
                 push: "push";
             }>>>;
+            zones: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniLiteral<true>, import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniNumber<number>>]>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
             currency: string;
             description?: string | undefined;
@@ -2581,6 +2619,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                     amount: string;
                 }[] | undefined;
                 supportedModes?: ("pull" | "push")[] | undefined;
+                zones?: true | number[] | undefined;
             } | undefined;
         }, {
             machineTokenEnabled?: boolean | undefined;
@@ -2599,6 +2638,7 @@ declare function chargeOffers<const parameters extends CurrencyParameters<charge
                 recipient: `0x${string}`;
             }[] | undefined;
             supportedModes?: ("pull" | "push")[] | undefined;
+            zones?: true | number[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<Omit<parameters, "chainId" | "currencies" | "currency" | "decimals"> & {