viem 2.47.19 → 2.48.0

package/_types/tempo/actions/zone.d.ts

@@ -0,0 +1,874 @@
+import type { Address } from 'abitype';
+import * as Hex from 'ox/Hex';
+import { TokenId, ZoneRpcAuthentication } from 'ox/tempo';
+import type { Account } from '../../accounts/types.js';
+import { type SendTransactionReturnType } from '../../actions/wallet/sendTransaction.js';
+import type { Client } from '../../clients/createClient.js';
+import type { Transport } from '../../clients/transports/createTransport.js';
+import type { BaseErrorType } from '../../errors/base.js';
+import type { Chain } from '../../types/chain.js';
+import type { Compute } from '../../types/utils.js';
+import type { RequestErrorType } from '../../utils/buildRequest.js';
+import type { GetAccountParameter, ReadParameters, WriteParameters } from '../internal/types.js';
+import * as Storage from '../Storage.js';
+import type { TransactionReceipt } from '../Transaction.js';
+export type EncryptedPayload = {
+    ciphertext: Hex.Hex;
+    ephemeralPubkeyX: Hex.Hex;
+    ephemeralPubkeyYParity: number;
+    nonce: Hex.Hex;
+    tag: Hex.Hex;
+};
+/**
+ * Deposits tokens into a zone on the parent Tempo chain.
+ * Batches approve and deposit into a single transaction.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { tempoModerato } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempoModerato,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.zone.deposit(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   zoneId: 7,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the parent Tempo chain.
+ * @param parameters - Deposit parameters.
+ * @returns The transaction hash.
+ */
+export declare function deposit<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: deposit.Parameters<chain, account>): Promise<deposit.ReturnValue>;
+export declare namespace deposit {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = WriteParameters<chain, account> & Omit<Args, 'chainId' | 'recipient'> & {
+        /** Recipient address in the zone. @default `account.address` */
+        recipient?: Address | undefined;
+    };
+    type Args = {
+        /** Amount of tokens to deposit. */
+        amount: bigint;
+        /** Parent chain ID (e.g. `42431` for moderato). */
+        chainId: number;
+        /** Optional deposit memo. @default `0x00...00` */
+        memo?: Hex.Hex | undefined;
+        /** Recipient address in the zone. */
+        recipient: Address;
+        /** Token address or ID to deposit. */
+        token: TokenId.TokenIdOrAddress;
+        /** Zone ID (e.g. `7`). */
+        zoneId: number;
+    };
+    type ReturnValue = SendTransactionReturnType;
+    type ErrorType = BaseErrorType;
+    /**
+     * Defines the calls to approve and deposit tokens into a zone.
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args: Args): (({
+        abi: [{
+            readonly name: "approve";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "address";
+                readonly name: "spender";
+            }, {
+                readonly type: "uint256";
+                readonly name: "amount";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "bool";
+            }];
+        }];
+        functionName: "approve";
+    } & {
+        args: readonly [spender: `0x${string}`, amount: bigint];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }) | ({
+        abi: [{
+            readonly name: "deposit";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly name: "_token";
+                readonly type: "address";
+            }, {
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint128";
+            }, {
+                readonly name: "memo";
+                readonly type: "bytes32";
+            }];
+            readonly outputs: readonly [{
+                readonly name: "";
+                readonly type: "bytes32";
+            }];
+        }];
+        functionName: "deposit";
+    } & {
+        args: readonly [_token: `0x${string}`, to: `0x${string}`, amount: bigint, memo: `0x${string}`];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }))[];
+}
+/**
+ * Deposits tokens into a zone on the parent Tempo chain and waits for the
+ * transaction receipt.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { tempoModerato } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempoModerato,
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.zone.depositSync(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   zoneId: 7,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the parent Tempo chain.
+ * @param parameters - Deposit parameters.
+ * @returns The transaction receipt.
+ */
+export declare function depositSync<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: depositSync.Parameters<chain, account>): Promise<depositSync.ReturnValue>;
+export declare namespace depositSync {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = deposit.Parameters<chain, account>;
+    type Args = deposit.Args;
+    type ReturnValue = Compute<{
+        /** Transaction receipt. */
+        receipt: TransactionReceipt;
+    }>;
+    type ErrorType = BaseErrorType;
+}
+/**
+ * Deposits tokens into a zone on the parent Tempo chain with encrypted
+ * recipient and memo. Batches approve and depositEncrypted into a single
+ * transaction.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { tempoModerato } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempoModerato,
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.zone.encryptedDeposit(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   zoneId: 7,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the parent Tempo chain.
+ * @param parameters - Encrypted deposit parameters.
+ * @returns The transaction hash.
+ */
+export declare function encryptedDeposit<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: encryptedDeposit.Parameters<chain, account>): Promise<encryptedDeposit.ReturnValue>;
+export declare namespace encryptedDeposit {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = WriteParameters<chain, account> & Omit<Args, 'chainId' | 'encrypted' | 'keyIndex' | 'recipient'> & {
+        /** Recipient address in the zone. @default `account.address` */
+        recipient?: Address | undefined;
+    };
+    type Args = {
+        /** Amount of tokens to deposit. */
+        amount: bigint;
+        /** Parent chain ID (e.g. `42431` for moderato). */
+        chainId: number;
+        /** Encrypted deposit payload. */
+        encrypted: EncryptedPayload;
+        /** Encryption key index from the portal contract. */
+        keyIndex: bigint;
+        /** Optional deposit memo. @default `0x00...00` */
+        memo?: Hex.Hex | undefined;
+        /** Recipient address in the zone. */
+        recipient: Address;
+        /** Token address or ID to deposit. */
+        token: TokenId.TokenIdOrAddress;
+        /** Zone ID (e.g. `7`). */
+        zoneId: number;
+    };
+    type ReturnValue = SendTransactionReturnType;
+    type ErrorType = BaseErrorType;
+    /**
+     * Defines the calls to approve and deposit tokens into a zone (encrypted).
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args: Args): (({
+        abi: [{
+            readonly name: "approve";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "address";
+                readonly name: "spender";
+            }, {
+                readonly type: "uint256";
+                readonly name: "amount";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "bool";
+            }];
+        }];
+        functionName: "approve";
+    } & {
+        args: readonly [spender: `0x${string}`, amount: bigint];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }) | ({
+        abi: [{
+            readonly name: "depositEncrypted";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint128";
+            }, {
+                readonly name: "keyIndex";
+                readonly type: "uint256";
+            }, {
+                readonly name: "encrypted";
+                readonly type: "tuple";
+                readonly components: readonly [{
+                    readonly name: "ephemeralPubkeyX";
+                    readonly type: "bytes32";
+                }, {
+                    readonly name: "ephemeralPubkeyYParity";
+                    readonly type: "uint8";
+                }, {
+                    readonly name: "ciphertext";
+                    readonly type: "bytes";
+                }, {
+                    readonly name: "nonce";
+                    readonly type: "bytes12";
+                }, {
+                    readonly name: "tag";
+                    readonly type: "bytes16";
+                }];
+            }];
+            readonly outputs: readonly [{
+                readonly name: "";
+                readonly type: "bytes32";
+            }];
+        }];
+        functionName: "depositEncrypted";
+    } & {
+        args: readonly [token: `0x${string}`, amount: bigint, bigint, {
+            ephemeralPubkeyX: `0x${string}`;
+            ephemeralPubkeyYParity: number;
+            ciphertext: `0x${string}`;
+            nonce: `0x${string}`;
+            tag: `0x${string}`;
+        }];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }))[];
+}
+/**
+ * Deposits tokens into a zone on the parent Tempo chain with encrypted
+ * recipient and memo, and waits for the transaction receipt.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { tempoModerato } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: tempoModerato,
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.zone.encryptedDepositSync(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   zoneId: 7,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the parent Tempo chain.
+ * @param parameters - Encrypted deposit parameters.
+ * @returns The transaction receipt.
+ */
+export declare function encryptedDepositSync<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: encryptedDepositSync.Parameters<chain, account>): Promise<encryptedDepositSync.ReturnValue>;
+export declare namespace encryptedDepositSync {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = encryptedDeposit.Parameters<chain, account>;
+    type Args = encryptedDeposit.Args;
+    type ReturnValue = Compute<{
+        /** Transaction receipt. */
+        receipt: TransactionReceipt;
+    }>;
+    type ErrorType = BaseErrorType;
+}
+/**
+ * Returns the authenticated account address and authorization token expiry.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const info = await Actions.zone.getAuthorizationTokenInfo(client)
+ * ```
+ *
+ * @param client - Zone client.
+ * @returns Authorization token info.
+ */
+export declare function getAuthorizationTokenInfo<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>): Promise<getAuthorizationTokenInfo.ReturnType>;
+export declare namespace getAuthorizationTokenInfo {
+    type RpcReturnType = {
+        account: Address;
+        expiresAt: Hex.Hex;
+    };
+    type ReturnType = {
+        account: Address;
+        expiresAt: bigint;
+    };
+    type ErrorType = RequestErrorType | BaseErrorType;
+}
+/**
+ * Returns deposit processing status for a given Tempo block number.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const status = await Actions.zone.getDepositStatus(client, {
+ *   tempoBlockNumber: 42n,
+ * })
+ * ```
+ *
+ * @param client - Zone client.
+ * @param parameters - Parameters including the Tempo block number.
+ * @returns Deposit status.
+ */
+export declare function getDepositStatus<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: getDepositStatus.Parameters): Promise<getDepositStatus.ReturnType>;
+export declare namespace getDepositStatus {
+    type DepositStatus = 'failed' | 'pending' | 'processed';
+    type DepositKind = 'encrypted' | 'regular';
+    type DepositRpc = {
+        amount: Hex.Hex;
+        depositHash: Hex.Hex;
+        kind: DepositKind;
+        memo: Hex.Hex | null;
+        recipient: Address | null;
+        sender: Address;
+        status: DepositStatus;
+        token: Address;
+    };
+    type Deposit = {
+        amount: bigint;
+        depositHash: Hex.Hex;
+        kind: DepositKind;
+        memo: Hex.Hex | null;
+        recipient: Address | null;
+        sender: Address;
+        status: DepositStatus;
+        token: Address;
+    };
+    type RpcReturnType = {
+        deposits: readonly DepositRpc[];
+        processed: boolean;
+        tempoBlockNumber: Hex.Hex;
+        zoneProcessedThrough: Hex.Hex;
+    };
+    type Parameters = {
+        tempoBlockNumber: bigint;
+    };
+    type ReturnType = {
+        deposits: readonly Deposit[];
+        processed: boolean;
+        tempoBlockNumber: bigint;
+        zoneProcessedThrough: bigint;
+    };
+    type ErrorType = RequestErrorType | BaseErrorType;
+}
+/**
+ * Returns the fee required for a withdrawal from a zone, given a gas limit.
+ *
+ * The client must be connected to the **zone chain**.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const fee = await Actions.zone.getWithdrawalFee(client)
+ * ```
+ *
+ * @param client - Zone client.
+ * @param parameters - Optional gas limit parameter.
+ * @returns The withdrawal fee as a bigint.
+ */
+export declare function getWithdrawalFee<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters?: getWithdrawalFee.Parameters): Promise<getWithdrawalFee.ReturnType>;
+export declare namespace getWithdrawalFee {
+    type Parameters = ReadParameters & {
+        /** Gas limit for the withdrawal callback. @default `0n` */
+        gas?: bigint | undefined;
+    };
+    type ReturnType = bigint;
+    type ErrorType = RequestErrorType | BaseErrorType;
+}
+/**
+ * Returns the current zone metadata.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const info = await Actions.zone.getZoneInfo(client)
+ * ```
+ *
+ * @param client - Zone client.
+ * @returns Zone metadata.
+ */
+export declare function getZoneInfo<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>): Promise<getZoneInfo.ReturnType>;
+export declare namespace getZoneInfo {
+    type RpcReturnType = {
+        chainId: Hex.Hex;
+        sequencer: Address;
+        zoneId: Hex.Hex;
+        zoneTokens: readonly Address[];
+    };
+    type ReturnType = {
+        chainId: number;
+        sequencer: Address;
+        zoneId: number;
+        zoneTokens: readonly Address[];
+    };
+    type ErrorType = RequestErrorType | BaseErrorType;
+}
+/**
+ * Requests a withdrawal from a zone to the parent Tempo chain via the
+ * ZoneOutbox contract.
+ *
+ * The client must be connected to the **zone chain**.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.zone.requestWithdrawal(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the zone chain.
+ * @param parameters - Withdrawal parameters.
+ * @returns The transaction hash.
+ */
+export declare function requestWithdrawal<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: requestWithdrawal.Parameters<chain, account>): Promise<requestWithdrawal.ReturnValue>;
+export declare namespace requestWithdrawal {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = WriteParameters<chain, account> & Omit<Args, 'to'> & {
+        /** Recipient address on the parent Tempo chain. @default `account.address` */
+        to?: Address | undefined;
+    };
+    type Args = {
+        /** Amount of tokens to withdraw. */
+        amount: bigint;
+        /** Optional callback data for the recipient. @default `'0x'` */
+        data?: Hex.Hex | undefined;
+        /** Fallback address if callback fails. @default `to` */
+        fallbackRecipient?: Address | undefined;
+        /** Gas limit reserved for the withdrawal callback on the parent chain. @default `0n` */
+        gas?: bigint | undefined;
+        /** Optional withdrawal memo. @default `0x00...00` */
+        memo?: Hex.Hex | undefined;
+        /** Recipient address on the parent Tempo chain. */
+        to: Address;
+        /** Token address or ID to withdraw. */
+        token: TokenId.TokenIdOrAddress;
+    };
+    type ReturnValue = SendTransactionReturnType;
+    type ErrorType = BaseErrorType;
+    /**
+     * Defines the calls to approve and request a withdrawal from a zone.
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args: Args): (({
+        abi: [{
+            readonly name: "approve";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "address";
+                readonly name: "spender";
+            }, {
+                readonly type: "uint256";
+                readonly name: "amount";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "bool";
+            }];
+        }];
+        functionName: "approve";
+    } & {
+        args: readonly [spender: `0x${string}`, amount: bigint];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }) | ({
+        abi: [{
+            readonly name: "requestWithdrawal";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint128";
+            }, {
+                readonly name: "memo";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "gasLimit";
+                readonly type: "uint64";
+            }, {
+                readonly name: "fallbackRecipient";
+                readonly type: "address";
+            }, {
+                readonly name: "data";
+                readonly type: "bytes";
+            }, {
+                readonly name: "revealTo";
+                readonly type: "bytes";
+            }];
+            readonly outputs: readonly [];
+        }];
+        functionName: "requestWithdrawal";
+    } & {
+        args: readonly [token: `0x${string}`, to: `0x${string}`, amount: bigint, memo: `0x${string}`, gasLimit: bigint, `0x${string}`, data: `0x${string}`, `0x${string}`];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }))[];
+}
+/**
+ * Requests a withdrawal from a zone to the parent Tempo chain and waits for
+ * the transaction receipt.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.zone.requestWithdrawalSync(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the zone chain.
+ * @param parameters - Withdrawal parameters.
+ * @returns The transaction receipt.
+ */
+export declare function requestWithdrawalSync<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: requestWithdrawalSync.Parameters<chain, account>): Promise<requestWithdrawalSync.ReturnValue>;
+export declare namespace requestWithdrawalSync {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = requestWithdrawal.Parameters<chain, account>;
+    type Args = requestWithdrawal.Args;
+    type ReturnValue = Compute<{
+        /** Transaction receipt. */
+        receipt: TransactionReceipt;
+    }>;
+    type ErrorType = BaseErrorType;
+}
+/**
+ * Requests a verifiable withdrawal from a zone to the parent Tempo chain via
+ * the ZoneOutbox contract. Includes a `revealTo` public key so the sequencer
+ * can encrypt the withdrawal details.
+ *
+ * The client must be connected to the **zone chain**.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const hash = await Actions.zone.requestVerifiableWithdrawal(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   revealTo: '0x02abc...def',
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the zone chain.
+ * @param parameters - Verifiable withdrawal parameters.
+ * @returns The transaction hash.
+ */
+export declare function requestVerifiableWithdrawal<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: requestVerifiableWithdrawal.Parameters<chain, account>): Promise<requestVerifiableWithdrawal.ReturnValue>;
+export declare namespace requestVerifiableWithdrawal {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = WriteParameters<chain, account> & Omit<Args, 'to'> & {
+        /** Recipient address on the parent Tempo chain. @default `account.address` */
+        to?: Address | undefined;
+    };
+    type Args = requestWithdrawal.Args & {
+        /** 33-byte compressed secp256k1 public key for encrypted reveal. */
+        revealTo: Hex.Hex;
+    };
+    type ReturnValue = SendTransactionReturnType;
+    type ErrorType = BaseErrorType;
+    /**
+     * Defines the calls to approve and request a verifiable withdrawal from a zone.
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args: Args): (({
+        abi: [{
+            readonly name: "approve";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly type: "address";
+                readonly name: "spender";
+            }, {
+                readonly type: "uint256";
+                readonly name: "amount";
+            }];
+            readonly outputs: readonly [{
+                readonly type: "bool";
+            }];
+        }];
+        functionName: "approve";
+    } & {
+        args: readonly [spender: `0x${string}`, amount: bigint];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }) | ({
+        abi: [{
+            readonly name: "requestWithdrawal";
+            readonly type: "function";
+            readonly stateMutability: "nonpayable";
+            readonly inputs: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly name: "to";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint128";
+            }, {
+                readonly name: "memo";
+                readonly type: "bytes32";
+            }, {
+                readonly name: "gasLimit";
+                readonly type: "uint64";
+            }, {
+                readonly name: "fallbackRecipient";
+                readonly type: "address";
+            }, {
+                readonly name: "data";
+                readonly type: "bytes";
+            }, {
+                readonly name: "revealTo";
+                readonly type: "bytes";
+            }];
+            readonly outputs: readonly [];
+        }];
+        functionName: "requestWithdrawal";
+    } & {
+        args: readonly [token: `0x${string}`, to: `0x${string}`, amount: bigint, memo: `0x${string}`, gasLimit: bigint, `0x${string}`, data: `0x${string}`, `0x${string}`];
+    } & {
+        address: Address;
+    } & {
+        data: import("../../index.js").Hex;
+        to: Address;
+    }))[];
+}
+/**
+ * Requests a verifiable withdrawal from a zone to the parent Tempo chain and
+ * waits for the transaction receipt.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.zone.requestVerifiableWithdrawalSync(client, {
+ *   token: '0x20c0...0001',
+ *   amount: 1_000_000n,
+ *   revealTo: '0x02abc...def',
+ * })
+ * ```
+ *
+ * @param client - Wallet client connected to the zone chain.
+ * @param parameters - Verifiable withdrawal parameters.
+ * @returns The transaction receipt.
+ */
+export declare function requestVerifiableWithdrawalSync<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, parameters: requestVerifiableWithdrawalSync.Parameters<chain, account>): Promise<requestVerifiableWithdrawalSync.ReturnValue>;
+export declare namespace requestVerifiableWithdrawalSync {
+    type Parameters<chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = requestVerifiableWithdrawal.Parameters<chain, account>;
+    type Args = requestVerifiableWithdrawal.Args;
+    type ReturnValue = Compute<{
+        /** Transaction receipt. */
+        receipt: TransactionReceipt;
+    }>;
+    type ErrorType = BaseErrorType;
+}
+/**
+ * Signs a zone authorization token and stores it for the zone HTTP transport.
+ *
+ * Zone chains should define `contracts.zonePortal` with the portal address.
+ * The `zoneId` is derived from `ZoneId.fromChainId(chain.id)` and can be overridden.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const result = await Actions.zone.signAuthorizationToken(client)
+ * ```
+ *
+ * @param client - Zone wallet client.
+ * @param parameters - Options including optional storage override.
+ * @returns The authentication object and serialized token.
+ */
+export declare function signAuthorizationToken<chain extends Chain | undefined, account extends Account | undefined, accountOverride extends Account | Address | undefined = undefined>(client: Client<Transport, chain, account>, parameters?: signAuthorizationToken.Parameters<account, accountOverride>): Promise<signAuthorizationToken.ReturnType>;
+export declare namespace signAuthorizationToken {
+    type Parameters<account extends Account | undefined = Account | undefined, accountOverride extends Account | Address | undefined = Account | Address | undefined> = GetAccountParameter<account, accountOverride> & {
+        /** Chain override. @default `client.chain`. */
+        chain?: Chain | undefined;
+        /** Token expiry as a unix timestamp (seconds). @default `issuedAt + 86_400`. */
+        expiresAt?: number | undefined;
+        /** Token issue time as a unix timestamp (seconds). @default `Date.now() / 1000`. */
+        issuedAt?: number | undefined;
+        /** Storage to persist the token. @default sessionStorage (web) or memory (server). */
+        storage?: Storage.Storage | undefined;
+    };
+    type ReturnType = {
+        authentication: ZoneRpcAuthentication.ZoneRpcAuthentication;
+        token: Hex.Hex;
+    };
+    type ErrorType = BaseErrorType;
+}
+//# sourceMappingURL=zone.d.ts.map