viem 2.55.0 → 2.55.2

package/_esm/tempo/actions/zone.js

@@ -4,13 +4,20 @@ import * as PublicKey from 'ox/PublicKey';
 import * as Secp256k1 from 'ox/Secp256k1';
 import { TokenId, ZoneId, ZoneRpcAuthentication } from 'ox/tempo';
 import { parseAccount } from '../../accounts/utils/parseAccount.js';
+import { multicall, } from '../../actions/public/multicall.js';
 import { readContract } from '../../actions/public/readContract.js';
+import { prepareTransactionRequest, } from '../../actions/wallet/prepareTransactionRequest.js';
 import { sendTransaction, } from '../../actions/wallet/sendTransaction.js';
 import { sendTransactionSync } from '../../actions/wallet/sendTransactionSync.js';
 import { zeroHash } from '../../constants/bytes.js';
+import { observe } from '../../utils/observe.js';
+import { poll } from '../../utils/poll.js';
+import { withResolvers } from '../../utils/promise/withResolvers.js';
+import { stringify } from '../../utils/stringify.js';
 import * as Abis from '../Abis.js';
 import * as Addresses from '../Addresses.js';
-import { defineCall, pickWriteParameters } from '../internal/utils.js';
+import { WaitForDepositStatusTimeoutError, } from '../errors.js';
+import { defineCall, pickWriteParameters, pickWriteSyncParameters, } from '../internal/utils.js';
 import * as Storage from '../Storage.js';
 import * as ZoneAbis from '../zones/Abis.js';
 import { getPortalAddress } from '../zones/zone.js';
@@ -48,14 +55,19 @@ export async function deposit(client, parameters) {
         throw new Error('`chain` is required.');
     const { account = client.account, ...rest } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
-    if (!account)
+    if (!account_)
         throw new Error('`account` is required.');
-    const recipient = parameters.recipient ?? account_?.address;
-    if (!recipient)
-        throw new Error('`recipient` is required.');
-    const args = { ...parameters, chainId, recipient };
+    const recipient = parameters.recipient ?? account_.address;
+    const bouncebackRecipient = parameters.bouncebackRecipient ?? account_.address;
+    const args = {
+        ...parameters,
+        bouncebackRecipient,
+        chainId,
+        recipient,
+    };
     return sendTransaction(client, {
         ...rest,
+        account,
         calls: deposit.calls(args),
     });
 }
@@ -67,22 +79,22 @@ export async function deposit(client, parameters) {
      * @returns The calls.
      */
     function calls(args) {
-        const { amount, chainId, memo = zeroHash, recipient, token, zoneId } = args;
-        const portalAddress = getPortalAddress(chainId, zoneId);
-        return [
-            defineCall({
-                address: TokenId.toAddress(token),
-                abi: Abis.tip20,
-                functionName: 'approve',
-                args: [portalAddress, amount],
-            }),
-            defineCall({
-                address: portalAddress,
-                abi: ZoneAbis.zonePortal,
-                functionName: 'deposit',
-                args: [TokenId.toAddress(token), recipient, amount, memo],
-            }),
-        ];
+        const { amount, bouncebackRecipient, chainId, memo = zeroHash, recipient, token, zoneId, } = args;
+        const portalAddress = args.portalAddress ?? getPortalAddress(chainId, zoneId);
+        const tokenAddress = TokenId.toAddress(token);
+        const approveCall = defineCall({
+            address: tokenAddress,
+            abi: Abis.tip20,
+            functionName: 'approve',
+            args: [portalAddress, amount],
+        });
+        const depositCall = defineCall({
+            address: portalAddress,
+            abi: ZoneAbis.zonePortal,
+            functionName: 'deposit',
+            args: [tokenAddress, recipient, amount, memo, bouncebackRecipient],
+        });
+        return [approveCall, depositCall];
     }
     deposit.calls = calls;
 })(deposit || (deposit = {}));
@@ -120,19 +132,98 @@ export async function depositSync(client, parameters) {
         throw new Error('`chain` is required.');
     const { account = client.account, throwOnReceiptRevert = true, ...rest } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
-    if (!account)
+    if (!account_)
         throw new Error('`account` is required.');
-    const recipient = parameters.recipient ?? account_?.address;
-    if (!recipient)
-        throw new Error('`recipient` is required.');
-    const args = { ...parameters, chainId, recipient };
+    const recipient = parameters.recipient ?? account_.address;
+    const bouncebackRecipient = parameters.bouncebackRecipient ?? account_.address;
+    const args = {
+        ...parameters,
+        bouncebackRecipient,
+        chainId,
+        recipient,
+    };
     const receipt = await sendTransactionSync(client, {
         ...rest,
+        account,
         throwOnReceiptRevert,
         calls: deposit.calls(args),
     });
     return { receipt };
 }
+/**
+ * Gets the active sequencer encryption key for a zone.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempoModerato } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempoModerato,
+ *   transport: http(),
+ * })
+ *
+ * const { keyIndex, publicKey } = await Actions.zone.getEncryptionKey(client, {
+ *   zoneId: 7,
+ * })
+ * ```
+ *
+ * @param client - Public client connected to the parent Tempo chain.
+ * @param parameters - Zone encryption key parameters.
+ * @returns The active encryption key and its zero-based index.
+ */
+export async function getEncryptionKey(client, parameters) {
+    const chainId = client.chain?.id;
+    if (!chainId)
+        throw new Error('`chain` is required.');
+    const { account, portalAddress: portalAddress_, zoneId, ...rest } = parameters;
+    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId);
+    const [keyCountResult, publicKeyResult] = await multicall(client, {
+        ...rest,
+        account: account ? parseAccount(account).address : undefined,
+        allowFailure: true,
+        batchSize: 0,
+        contracts: getEncryptionKey.calls({ portalAddress }),
+        deployless: true,
+    });
+    if (keyCountResult.status === 'failure')
+        throw keyCountResult.error;
+    const keyCount = keyCountResult.result;
+    if (keyCount === 0n || publicKeyResult.status === 'failure')
+        throw keyCount === 0n
+            ? new Error('No sequencer encryption key configured.')
+            : publicKeyResult.error;
+    const [x, prefix] = publicKeyResult.result;
+    PublicKey.assert({ prefix, x: Hex.toBigInt(x) }, { compressed: true });
+    return {
+        keyIndex: keyCount - 1n,
+        publicKey: { prefix: prefix, x },
+    };
+}
+(function (getEncryptionKey) {
+    /**
+     * Defines calls to the encryption key count and active sequencer key.
+     *
+     * @param args - Arguments.
+     * @returns The calls.
+     */
+    function calls(args) {
+        return [
+            defineCall({
+                address: args.portalAddress,
+                abi: ZoneAbis.zonePortal,
+                functionName: 'encryptionKeyCount',
+            }),
+            defineCall({
+                address: args.portalAddress,
+                abi: ZoneAbis.zonePortal,
+                functionName: 'sequencerEncryptionKey',
+            }),
+        ];
+    }
+    getEncryptionKey.calls = calls;
+})(getEncryptionKey || (getEncryptionKey = {}));
 /**
  * Deposits tokens into a zone on the parent Tempo chain with encrypted
  * recipient and memo. Batches approve and depositEncrypted into a single
@@ -168,29 +259,34 @@ export async function encryptedDeposit(client, parameters) {
         throw new Error('`chain` is required.');
     const { account = client.account, ...rest } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
-    if (!account)
+    if (!account_)
         throw new Error('`account` is required.');
+    const bouncebackRecipient = parameters.bouncebackRecipient ?? account_.address;
     if ('encrypted' in parameters) {
         if (parameters.chainId !== chainId) {
             throw new Error('Prepared encrypted deposit chain ID does not match client chain.');
         }
         return sendTransaction(client, {
             ...pickWriteParameters(parameters),
-            calls: encryptedDeposit.calls(parameters),
+            calls: encryptedDeposit.calls({
+                ...parameters,
+                bouncebackRecipient,
+            }),
         });
     }
-    const recipient = parameters.recipient ?? account_?.address;
-    if (!recipient)
-        throw new Error('`recipient` is required.');
+    const recipient = parameters.recipient ?? account_.address;
     const prepared = await encryptedDeposit.prepare(client, {
         amount: parameters.amount,
+        bouncebackRecipient,
         memo: parameters.memo,
+        portalAddress: parameters.portalAddress,
         recipient,
         token: parameters.token,
         zoneId: parameters.zoneId,
     });
     return sendTransaction(client, {
         ...rest,
+        account,
         calls: encryptedDeposit.calls(prepared),
     });
 }
@@ -212,6 +308,7 @@ export async function encryptedDeposit(client, parameters) {
      * const prepared = await Actions.zone.encryptedDeposit.prepare(client, {
      *   token: '0x20c0...0001',
      *   amount: 1_000_000n,
+     *   bouncebackRecipient: '0x...',
      *   recipient: '0x...',
      *   zoneId: 7,
      * })
@@ -225,37 +322,75 @@ export async function encryptedDeposit(client, parameters) {
         const chainId = client.chain?.id;
         if (!chainId)
             throw new Error('`chain` is required.');
-        const { amount, memo, recipient, token, zoneId, ...rest } = parameters;
-        const portalAddress = getPortalAddress(chainId, zoneId);
-        const [publicKey, keyIndex] = await Promise.all([
-            readContract(client, {
-                ...rest,
-                address: portalAddress,
-                abi: ZoneAbis.zonePortal,
-                functionName: 'sequencerEncryptionKey',
-            }),
-            readContract(client, {
-                ...rest,
-                address: portalAddress,
-                abi: ZoneAbis.zonePortal,
-                functionName: 'encryptionKeyCount',
-            }),
-        ]);
-        if (keyIndex === 0n) {
-            throw new Error('No sequencer encryption key configured.');
-        }
-        const encrypted = await encryptDepositPayload({ x: publicKey[0], yParity: publicKey[1] }, recipient, portalAddress, keyIndex - 1n, memo);
+        const { amount, bouncebackRecipient, memo, portalAddress: portalAddress_, recipient, token, zoneId, ...rest } = parameters;
+        const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId);
+        const { keyIndex, publicKey } = await getEncryptionKey(client, {
+            ...rest,
+            portalAddress,
+            zoneId,
+        });
+        const encrypted = await encryptDepositPayload(publicKey, recipient, portalAddress, keyIndex, memo);
         return {
             amount,
+            bouncebackRecipient,
             chainId,
             encrypted,
-            keyIndex: keyIndex - 1n,
+            keyIndex,
             portalAddress,
             token,
             zoneId,
         };
     }
     encryptedDeposit.prepare = prepare;
+    /**
+     * Prepares encrypted Zone recipient instructions without constructing a token
+     * deposit.
+     *
+     * Use this when another contract or service controls the token movement and
+     * only needs the ZonePortal `keyIndex` and encrypted recipient payload.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempoModerato } from 'viem/chains'
+     * import { Actions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempoModerato,
+     *   transport: http(),
+     * })
+     *
+     * const recipient = await Actions.zone.encryptedDeposit.prepareRecipient(client, {
+     *   recipient: '0x...',
+     *   zoneId: 7,
+     * })
+     * ```
+     *
+     * @param client - Public client connected to the parent Tempo chain.
+     * @param parameters - Encrypted recipient preparation parameters.
+     * @returns Prepared encrypted recipient instructions.
+     */
+    async function prepareRecipient(client, parameters) {
+        const chainId = client.chain?.id;
+        if (!chainId)
+            throw new Error('`chain` is required.');
+        const { memo, portalAddress: portalAddress_, recipient, zoneId, ...rest } = parameters;
+        const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId);
+        const { keyIndex, publicKey } = await getEncryptionKey(client, {
+            ...rest,
+            portalAddress,
+            zoneId,
+        });
+        const encrypted = await encryptDepositPayload(publicKey, recipient, portalAddress, keyIndex, memo);
+        return {
+            chainId,
+            encrypted,
+            keyIndex,
+            portalAddress,
+            zoneId,
+        };
+    }
+    encryptedDeposit.prepareRecipient = prepareRecipient;
     /**
      * Defines the calls to approve and deposit tokens into a zone (encrypted).
      *
@@ -263,33 +398,35 @@ export async function encryptedDeposit(client, parameters) {
      * @returns The calls.
      */
     function calls(args) {
-        const { amount, chainId, encrypted, keyIndex, token, zoneId } = args;
-        const portalAddress = getPortalAddress(chainId, zoneId);
-        return [
-            defineCall({
-                address: TokenId.toAddress(token),
-                abi: Abis.tip20,
-                functionName: 'approve',
-                args: [portalAddress, amount],
-            }),
-            defineCall({
-                address: portalAddress,
-                abi: ZoneAbis.zonePortal,
-                functionName: 'depositEncrypted',
-                args: [
-                    TokenId.toAddress(token),
-                    amount,
-                    keyIndex,
-                    {
-                        ephemeralPubkeyX: encrypted.ephemeralPubkeyX,
-                        ephemeralPubkeyYParity: encrypted.ephemeralPubkeyYParity,
-                        ciphertext: encrypted.ciphertext,
-                        nonce: encrypted.nonce,
-                        tag: encrypted.tag,
-                    },
-                ],
-            }),
-        ];
+        const { amount, bouncebackRecipient, chainId, encrypted, keyIndex, token, zoneId, } = args;
+        const portalAddress = args.portalAddress ?? getPortalAddress(chainId, zoneId);
+        const tokenAddress = TokenId.toAddress(token);
+        const encryptedPayload = {
+            ephemeralPubkeyX: encrypted.ephemeralPubkeyX,
+            ephemeralPubkeyYParity: encrypted.ephemeralPubkeyYParity,
+            ciphertext: encrypted.ciphertext,
+            nonce: encrypted.nonce,
+            tag: encrypted.tag,
+        };
+        const approveCall = defineCall({
+            address: tokenAddress,
+            abi: Abis.tip20,
+            functionName: 'approve',
+            args: [portalAddress, amount],
+        });
+        const depositCall = defineCall({
+            address: portalAddress,
+            abi: ZoneAbis.zonePortal,
+            functionName: 'depositEncrypted',
+            args: [
+                tokenAddress,
+                amount,
+                keyIndex,
+                encryptedPayload,
+                bouncebackRecipient,
+            ],
+        });
+        return [approveCall, depositCall];
     }
     encryptedDeposit.calls = calls;
 })(encryptedDeposit || (encryptedDeposit = {}));
@@ -327,31 +464,37 @@ export async function encryptedDepositSync(client, parameters) {
         throw new Error('`chain` is required.');
     const { account = client.account, throwOnReceiptRevert = true, ...rest } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
-    if (!account)
+    if (!account_)
         throw new Error('`account` is required.');
+    const bouncebackRecipient = parameters.bouncebackRecipient ?? account_.address;
     if ('encrypted' in parameters) {
         if (parameters.chainId !== chainId) {
             throw new Error('Prepared encrypted deposit chain ID does not match client chain.');
         }
         const receipt = await sendTransactionSync(client, {
             ...pickWriteParameters(parameters),
+            ...pickWriteSyncParameters(parameters),
             throwOnReceiptRevert,
-            calls: encryptedDeposit.calls(parameters),
+            calls: encryptedDeposit.calls({
+                ...parameters,
+                bouncebackRecipient,
+            }),
         });
         return { receipt };
     }
-    const recipient = parameters.recipient ?? account_?.address;
-    if (!recipient)
-        throw new Error('`recipient` is required.');
+    const recipient = parameters.recipient ?? account_.address;
     const prepared = await encryptedDeposit.prepare(client, {
         amount: parameters.amount,
+        bouncebackRecipient,
         memo: parameters.memo,
+        portalAddress: parameters.portalAddress,
         recipient,
         token: parameters.token,
         zoneId: parameters.zoneId,
     });
     const receipt = await sendTransactionSync(client, {
         ...rest,
+        account,
         throwOnReceiptRevert,
         calls: encryptedDeposit.calls(prepared),
     });
@@ -433,7 +576,79 @@ export async function getDepositStatus(client, parameters) {
     };
 }
 /**
- * Returns the fee required for a withdrawal from a zone, given a gas limit.
+ * Waits for a Tempo block's deposits to be processed by a zone.
+ *
+ * @example
+ * ```ts
+ * import { createClient } from 'viem'
+ * import { Actions } from 'viem/tempo'
+ * import { http, zoneModerato } from 'viem/tempo/zones'
+ *
+ * const client = createClient({
+ *   chain: zoneModerato(7),
+ *   transport: http(),
+ * })
+ *
+ * const status = await Actions.zone.waitForDepositStatus(client, {
+ *   tempoBlockNumber: 42n,
+ * })
+ * ```
+ *
+ * @param client - Zone client.
+ * @param parameters - Tempo block number and polling options.
+ * @returns The processed deposit status.
+ */
+export async function waitForDepositStatus(client, parameters) {
+    const { pollingInterval = client.pollingInterval, tempoBlockNumber, timeout = 60_000, } = parameters;
+    const observerId = stringify([
+        'waitForDepositStatus',
+        client.uid,
+        tempoBlockNumber,
+    ]);
+    const { promise, reject, resolve } = withResolvers();
+    let timer;
+    let unobserve;
+    const cleanup = () => {
+        clearTimeout(timer);
+        unobserve();
+    };
+    const resolve_ = (status) => {
+        cleanup();
+        resolve(status);
+    };
+    const reject_ = (error) => {
+        cleanup();
+        reject(error);
+    };
+    unobserve = observe(observerId, { reject: reject_, resolve: resolve_ }, (emit) => {
+        const unpoll = poll(async () => {
+            try {
+                const status = await getDepositStatus(client, { tempoBlockNumber });
+                if (!status.processed)
+                    return;
+                unpoll();
+                emit.resolve(status);
+            }
+            catch (error) {
+                unpoll();
+                emit.reject(error);
+            }
+        }, {
+            emitOnBegin: true,
+            interval: pollingInterval,
+        });
+        return unpoll;
+    });
+    timer = timeout
+        ? setTimeout(() => {
+            reject_(new WaitForDepositStatusTimeoutError({ tempoBlockNumber }));
+        }, timeout)
+        : undefined;
+    return await promise;
+}
+/**
+ * Returns the fee required for a withdrawal from a zone, given a callback gas
+ * limit.
  *
  * The client must be connected to the **zone chain**.
  *
@@ -452,17 +667,17 @@ export async function getDepositStatus(client, parameters) {
  * ```
  *
  * @param client - Zone client.
- * @param parameters - Optional gas limit parameter.
+ * @param parameters - Optional callback gas limit parameter.
  * @returns The withdrawal fee as a bigint.
  */
 export async function getWithdrawalFee(client, parameters = {}) {
-    const { gas = 0n, ...rest } = parameters;
+    const { callbackGas = 0n, ...rest } = parameters;
     return readContract(client, {
         ...rest,
         address: Addresses.zoneOutbox,
         abi: ZoneAbis.zoneOutbox,
         functionName: 'calculateWithdrawalFee',
-        args: [gas],
+        args: [callbackGas],
     });
 }
 /**
@@ -527,7 +742,7 @@ export async function getZoneInfo(client) {
  * @returns The transaction hash.
  */
 export async function requestWithdrawal(client, parameters) {
-    const { account = client.account, ...rest } = parameters;
+    const { account = client.account } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
     if (!account)
         throw new Error('`account` is required.');
@@ -536,7 +751,7 @@ export async function requestWithdrawal(client, parameters) {
         throw new Error('`to` is required.');
     const args = { ...parameters, to };
     return sendTransaction(client, {
-        ...rest,
+        ...pickWriteParameters(parameters),
         calls: requestWithdrawal.calls(args),
     });
 }
@@ -548,7 +763,7 @@ export async function requestWithdrawal(client, parameters) {
      * @returns The calls.
      */
     function calls(args) {
-        const { amount, data = '0x', fallbackRecipient = args.to, gas = 0n, memo = zeroHash, to, token, } = args;
+        const { amount, callbackGas = 0n, data = '0x', fallbackRecipient = args.to, memo = zeroHash, to, token, } = args;
         return [
             defineCall({
                 address: TokenId.toAddress(token),
@@ -565,7 +780,7 @@ export async function requestWithdrawal(client, parameters) {
                     to,
                     amount,
                     memo,
-                    gas,
+                    callbackGas,
                     fallbackRecipient,
                     data,
                     '0x',
@@ -574,6 +789,73 @@ export async function requestWithdrawal(client, parameters) {
         ];
     }
     requestWithdrawal.calls = calls;
+    /**
+     * Prepares a zone withdrawal transaction request without broadcasting it.
+     *
+     * Use this to inspect or modify the populated ZoneOutbox transaction request
+     * and its maximum transaction fee before submitting a withdrawal.
+     *
+     * @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 prepared = await Actions.zone.requestWithdrawal.prepare(client, {
+     *   token: '0x20c0...0001',
+     *   amount: 1_000_000n,
+     *   to: '0x...',
+     * })
+     *
+     * console.log(prepared.maxFee)
+     * console.log(prepared.request.gas)
+     * ```
+     *
+     * @param client - Zone client.
+     * @param parameters - Withdrawal preparation parameters.
+     * @returns The prepared transaction request, maximum fee, and withdrawal details.
+     */
+    async function prepare(client, parameters) {
+        const { account = client.account, amount, callbackGas = 0n, data = '0x', fallbackRecipient, memo = zeroHash, to: to_, token, ...transactionRequest } = parameters;
+        const account_ = account ? parseAccount(account) : undefined;
+        const to = to_ ?? account_?.address;
+        if (!to)
+            throw new Error('`to` is required.');
+        const request = await prepareTransactionRequest(client, {
+            ...transactionRequest,
+            account,
+            calls: requestWithdrawal.calls({
+                amount,
+                callbackGas,
+                data,
+                fallbackRecipient,
+                memo,
+                to,
+                token,
+            }),
+        });
+        const feePerGas = request.maxFeePerGas ?? request.gasPrice;
+        if (typeof request.gas !== 'bigint' || typeof feePerGas !== 'bigint')
+            throw new Error('Prepared transaction fee parameters are unavailable.');
+        const maxFee = ceilDiv(request.gas * feePerGas, 1000000000000n);
+        return {
+            amount,
+            callbackGas,
+            data,
+            fallbackRecipient: fallbackRecipient ?? to,
+            maxFee,
+            memo,
+            request,
+            to,
+            token,
+        };
+    }
+    requestWithdrawal.prepare = prepare;
 })(requestWithdrawal || (requestWithdrawal = {}));
 /**
  * Requests a withdrawal from a zone to the parent Tempo chain and waits for
@@ -603,7 +885,7 @@ export async function requestWithdrawal(client, parameters) {
  * @returns The transaction receipt.
  */
 export async function requestWithdrawalSync(client, parameters) {
-    const { account = client.account, throwOnReceiptRevert = true, ...rest } = parameters;
+    const { account = client.account, throwOnReceiptRevert = true } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
     if (!account)
         throw new Error('`account` is required.');
@@ -612,7 +894,8 @@ export async function requestWithdrawalSync(client, parameters) {
         throw new Error('`to` is required.');
     const args = { ...parameters, to };
     const receipt = await sendTransactionSync(client, {
-        ...rest,
+        ...pickWriteParameters(parameters),
+        ...pickWriteSyncParameters(parameters),
         calls: requestWithdrawal.calls(args),
         throwOnReceiptRevert,
     });
@@ -650,7 +933,7 @@ export async function requestWithdrawalSync(client, parameters) {
  * @returns The transaction hash.
  */
 export async function requestVerifiableWithdrawal(client, parameters) {
-    const { account = client.account, ...rest } = parameters;
+    const { account = client.account } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
     if (!account)
         throw new Error('`account` is required.');
@@ -659,7 +942,7 @@ export async function requestVerifiableWithdrawal(client, parameters) {
         throw new Error('`to` is required.');
     const args = { ...parameters, to };
     return sendTransaction(client, {
-        ...rest,
+        ...pickWriteParameters(parameters),
         calls: requestVerifiableWithdrawal.calls(args),
     });
 }
@@ -671,7 +954,7 @@ export async function requestVerifiableWithdrawal(client, parameters) {
      * @returns The calls.
      */
     function calls(args) {
-        const { amount, data = '0x', fallbackRecipient = args.to, gas = 0n, memo = zeroHash, revealTo, to, token, } = args;
+        const { amount, callbackGas = 0n, data = '0x', fallbackRecipient = args.to, memo = zeroHash, revealTo, to, token, } = args;
         return [
             defineCall({
                 address: TokenId.toAddress(token),
@@ -688,7 +971,7 @@ export async function requestVerifiableWithdrawal(client, parameters) {
                     to,
                     amount,
                     memo,
-                    gas,
+                    callbackGas,
                     fallbackRecipient,
                     data,
                     revealTo,
@@ -727,7 +1010,7 @@ export async function requestVerifiableWithdrawal(client, parameters) {
  * @returns The transaction receipt.
  */
 export async function requestVerifiableWithdrawalSync(client, parameters) {
-    const { account = client.account, throwOnReceiptRevert = true, ...rest } = parameters;
+    const { account = client.account, throwOnReceiptRevert = true } = parameters;
     const account_ = account ? parseAccount(account) : undefined;
     if (!account)
         throw new Error('`account` is required.');
@@ -736,7 +1019,8 @@ export async function requestVerifiableWithdrawalSync(client, parameters) {
         throw new Error('`to` is required.');
     const args = { ...parameters, to };
     const receipt = await sendTransactionSync(client, {
-        ...rest,
+        ...pickWriteParameters(parameters),
+        ...pickWriteSyncParameters(parameters),
         calls: requestVerifiableWithdrawal.calls(args),
         throwOnReceiptRevert,
     });
@@ -773,6 +1057,7 @@ export async function signAuthorizationToken(client, parameters = {}) {
     const chain = parameters.chain ?? client.chain;
     if (!chain)
         throw new Error('`signAuthorizationToken` requires a chain.');
+    const zoneId = parameters.zoneId ?? ZoneId.fromChainId(chain.id);
     const account_ = account ? parseAccount(account) : undefined;
     if (!account_ || !account_.sign)
         throw new Error('`account` with `sign` is required.');
@@ -781,7 +1066,7 @@ export async function signAuthorizationToken(client, parameters = {}) {
         chainId: chain.id,
         expiresAt,
         issuedAt,
-        zoneId: ZoneId.fromChainId(chain.id),
+        zoneId,
     });
     const payload = ZoneRpcAuthentication.getSignPayload(authentication);
     const signature = await account_.sign({ hash: payload });
@@ -799,7 +1084,7 @@ export async function signAuthorizationToken(client, parameters = {}) {
  */
 async function encryptDepositPayload(publicKey, recipient, portalAddress, keyIndex, memo = zeroHash) {
     const sequencerPublicKey = PublicKey.from({
-        prefix: publicKey.yParity,
+        prefix: publicKey.prefix,
         x: Hex.toBigInt(publicKey.x),
     });
     const { privateKey: ephemeralPrivateKey, publicKey: ephemeralPublicKey } = Secp256k1.createKeyPair();
@@ -835,4 +1120,7 @@ function buildDepositPlaintext(recipient, memo) {
 function buildDepositHkdfInfo(portalAddress, keyIndex, ephemeralPubkeyX) {
     return Bytes.concat(Bytes.from(portalAddress), Bytes.fromNumber(keyIndex, { size: 32 }), Bytes.from(ephemeralPubkeyX));
 }
+function ceilDiv(numerator, denominator) {
+    return (numerator + denominator - 1n) / denominator;
+}
 //# sourceMappingURL=zone.js.map