@aztec-labs/cli 6.0.0-nightly.20261006 → 6.0.0-nightly.20261007

package/dest/cmds/l1/index.d.ts

@@ -1,4 +1,4 @@
 import type { LogFn, Logger } from '@aztec-labs/foundation/log';
 import { type Command } from 'commander';
 export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF1QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBOGdCL0UifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF3QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBbW1CL0UifQ==

package/dest/cmds/l1/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAuBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WA8gB/E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAwBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAmmB/E"}

package/dest/cmds/l1/index.js

@@ -1,7 +1,7 @@
 import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
 import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import { Option } from 'commander';
-import { ETHEREUM_HOSTS, MNEMONIC, PRIVATE_KEY, l1ChainIdOption, nodeOption, parseBigint, parseEthereumAddress } from '../../utils/commands.js';
+import { ETHEREUM_HOSTS, MNEMONIC, PRIVATE_KEY, l1ChainIdOption, nodeOption, parseBigint, parseEthereumAddress, parseOptionalInteger } from '../../utils/commands.js';
 const l1RpcUrlsOption = new Option('--l1-rpc-urls <string>', 'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)').env('ETHEREUM_HOSTS').default([
     ETHEREUM_HOSTS
 ]).makeOptionMandatory(true).argParser((arg)=>arg.split(',').map((url)=>url.trim()));
@@ -120,28 +120,67 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('initiate-withdraw-by-attester').description("Initiates a withdrawal signed by the position's attester.").addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-pk, --private-key <string>', 'The attester private key', PRIVATE_KEY).option('-m, --mnemonic <string>', 'Mnemonic for the attester account', MNEMONIC).requiredOption('--attester <address>', 'Attester address of the position to exit', parseEthereumAddress).requiredOption('--rollup <address>', 'Rollup holding the position', parseEthereumAddress).action(async (options)=>{
+    addSignerOptions(program.command('initiate-withdraw-by-attester').description("Initiates a withdrawal signed by the position's attester."), 'attester').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).requiredOption('--attester <address>', 'Attester address of the position to exit', parseEthereumAddress).requiredOption('--rollup <address>', 'Rollup holding the position', parseEthereumAddress).action(async (options)=>{
         const { initiateWithdrawByAttester } = await import('./update_l1_validators.js');
         await initiateWithdrawByAttester({
             rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
+            accountIndex: options.accountIndex,
+            addressIndex: options.addressIndex,
             attesterAddress: options.attester,
             rollupAddress: options.rollup,
             log,
             debugLogger
         });
     });
-    program.command('initiate-withdraw-by-attester-batch').description('Relays a JSON array of attester-signed withdrawal authorizations.').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-pk, --private-key <string>', 'The relayer private key', PRIVATE_KEY).option('-m, --mnemonic <string>', 'Mnemonic for the relayer account', MNEMONIC).requiredOption('--authorizations <path>', 'JSON file containing attester, decimal deadline, and signature fields').requiredOption('--rollup <address>', 'Rollup holding the positions', parseEthereumAddress).option('--up-to-limit', 'Process the largest permitted prefix instead of reverting when the whole batch is too large').action(async (options)=>{
+    addSignerOptions(program.command('sign-attester-exit').description('Signs an exit authorization locally and writes a JSON array for batch submission.'), 'attester').addOption(new Option('--l1-rpc-urls <string>', 'Ethereum host URLs (comma separated); when given, the chain ID they report must match, and they supply it or the rollup when those are not given').env('ETHEREUM_HOSTS').argParser((arg)=>arg.split(',').map((url)=>url.trim()))).addOption(new Option('-c, --l1-chain-id <number>', 'Chain ID to sign for; required unless --network or --l1-rpc-urls supplies it, and a value from L1_CHAIN_ID alone must be confirmed by one of them').env('L1_CHAIN_ID').argParser(Number)).addOption(networkOption).requiredOption('--attester <address>', 'Attester address of the position to exit', parseEthereumAddress).option('--rollup <address>', 'Rollup holding the position; defaults to the canonical rollup of --network', parseEthereumAddress).requiredOption('--deadline <timestamp>', 'Authorization expiry as Unix seconds', parseBigint).requiredOption('--output <path>', 'JSON output file (must be new unless --append is used)').option('--append', 'Append or create if missing, without validating existing authorizations; run initiate-withdraw-by-attester-batch --dry-run after the batch is complete').addHelpText('after', `
+Examples:
+  aztec sign-attester-exit --private-key "$ATTESTER_KEY_0" --attester "$ATTESTER_0" --rollup "$ROLLUP" --l1-chain-id "$CHAIN_ID" --deadline "$DEADLINE" --output exits.json --append
+  aztec sign-attester-exit --private-key "$ATTESTER_KEY_1" --attester "$ATTESTER_1" --rollup "$ROLLUP" --l1-chain-id "$CHAIN_ID" --deadline "$DEADLINE" --output exits.json --append
+  aztec sign-attester-exit --mnemonic "$VALIDATOR_MNEMONIC" --account-index 0 --address-index 2 --attester "$ATTESTER_2" --rollup "$ROLLUP" --l1-chain-id "$CHAIN_ID" --deadline "$DEADLINE" --output exits.json --append
+  aztec sign-attester-exit --network testnet --l1-rpc-urls "$L1_RPC_URL" --private-key "$ATTESTER_KEY_3" --attester "$ATTESTER_3" --deadline "$DEADLINE" --output exits.json --append
+  aztec initiate-withdraw-by-attester-batch --dry-run --authorizations exits.json --rollup "$ROLLUP" --l1-chain-id "$CHAIN_ID" --l1-rpc-urls "$L1_RPC_URL"
+  aztec initiate-withdraw-by-attester-batch --authorizations exits.json --rollup "$ROLLUP" --l1-chain-id "$CHAIN_ID" --l1-rpc-urls "$L1_RPC_URL" --private-key "$RELAYER_PRIVATE_KEY"
+Note: DEADLINE is a future Unix timestamp in seconds. Run append commands sequentially.
+`).action(async (options, command)=>{
+        const { getAttesterExitNetwork, resolveAttesterExitTarget, signAttesterExit } = await import('./update_l1_validators.js');
+        const { chainId, rollupAddress } = await resolveAttesterExitTarget({
+            chainId: options.l1ChainId,
+            chainIdFromEnv: command.getOptionValueSource('l1ChainId') === 'env',
+            rpcUrls: options.l1RpcUrls,
+            network: options.network ? await getAttesterExitNetwork(options.network) : undefined,
+            rollupAddress: options.rollup,
+            log
+        });
+        await signAttesterExit({
+            rpcUrls: options.l1RpcUrls ?? [],
+            chainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            accountIndex: options.accountIndex,
+            addressIndex: options.addressIndex,
+            attesterAddress: options.attester,
+            rollupAddress,
+            deadline: options.deadline,
+            output: options.output,
+            append: options.append,
+            log
+        });
+    });
+    addSignerOptions(program.command('initiate-withdraw-by-attester-batch').description('Relays a JSON array of attester-signed withdrawal authorizations.'), 'relayer').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).requiredOption('--authorizations <path>', 'JSON file containing attester, decimal deadline, and signature fields').requiredOption('--rollup <address>', 'Rollup holding the positions', parseEthereumAddress).option('--up-to-limit', 'Process the largest permitted prefix instead of reverting when the whole batch is too large').option('--dry-run', 'Simulate against current chain state without sending; no relayer key is required').action(async (options)=>{
         const { initiateWithdrawByAttesterBatch, readAttesterExitAuthorizations } = await import('./update_l1_validators.js');
         await initiateWithdrawByAttesterBatch({
             rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
+            accountIndex: options.accountIndex,
+            addressIndex: options.addressIndex,
             authorizations: await readAttesterExitAuthorizations(options.authorizations),
             upToLimit: options.upToLimit,
+            dryRun: options.dryRun,
             rollupAddress: options.rollup,
             log,
             debugLogger
@@ -226,3 +265,17 @@ export function injectCommands(program, log, debugLogger) {
     });
     return program;
 }
+function addSignerOptions(command, role) {
+    return command.addOption(new Option('-pk, --private-key <string>', `The ${role} private key; supply this or --mnemonic`).env('PRIVATE_KEY')).addOption(new Option('-m, --mnemonic <string>', `Mnemonic for the ${role} account; a flag overrides the other credential from the environment, and PRIVATE_KEY wins when both come from the environment`).env('MNEMONIC')).option('--account-index <number>', 'Mnemonic account index, matching validator-keys generation (default: 0; requires --mnemonic)', (value)=>parseOptionalInteger(value, 0)).option('--address-index <number>', role === 'attester' ? 'Mnemonic address index: validator-keys base address index + zero-based validator position; third validator = base + 2 (default: 0; requires --mnemonic)' : 'Mnemonic address index for the relayer paying for the transaction; attesters sign authorizations separately (default: 0; requires --mnemonic)', (value)=>parseOptionalInteger(value, 0)).hook('preAction', (_, actionCommand)=>{
+        const { privateKey, mnemonic } = actionCommand.opts();
+        if (!privateKey || !mnemonic) {
+            return;
+        }
+        // Only two credentials passed as flags are a conflict; otherwise drop the one that came from the environment.
+        if (actionCommand.getOptionValueSource('mnemonic') === 'env') {
+            actionCommand.setOptionValue('mnemonic', undefined);
+        } else if (actionCommand.getOptionValueSource('privateKey') === 'env') {
+            actionCommand.setOptionValue('privateKey', undefined);
+        }
+    });
+}

package/dest/cmds/l1/l1_rpc_test_utils.d.ts

@@ -0,0 +1,14 @@
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+/**
+ * Starts a JSON-RPC server that reports `chainId` and, when `canonicalRollup` is given, answers every `eth_call` with
+ * that address and records the call. Any other method gets an error.
+ */
+export declare function serveL1Rpc(chainId: number, canonicalRollup?: EthAddress): Promise<{
+    url: string;
+    registryCalls: {
+        to: string;
+        data: string;
+    }[];
+    close: () => Promise<unknown>;
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfcnBjX3Rlc3RfdXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2wxX3JwY190ZXN0X3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBSXJFOzs7R0FHRztBQUNILHdCQUFzQixVQUFVLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxlQUFlLENBQUMsRUFBRSxVQUFVOzs7Ozs7O0dBa0M3RSJ9

package/dest/cmds/l1/l1_rpc_test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_rpc_test_utils.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/l1_rpc_test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAIrE;;;GAGG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,UAAU;;;;;;;GAkC7E"}

package/dest/cmds/l1/l1_rpc_test_utils.js

@@ -0,0 +1,58 @@
+import { createServer } from 'node:http';
+import { encodeAbiParameters } from 'viem';
+/**
+ * Starts a JSON-RPC server that reports `chainId` and, when `canonicalRollup` is given, answers every `eth_call` with
+ * that address and records the call. Any other method gets an error.
+ */ export async function serveL1Rpc(chainId, canonicalRollup) {
+    const registryCalls = [];
+    const server = createServer((request, response)=>{
+        let body = '';
+        request.on('data', (chunk)=>body += chunk);
+        request.on('end', ()=>{
+            const { id, method, params } = JSON.parse(body);
+            response.setHeader('content-type', 'application/json');
+            if (method === 'eth_chainId') {
+                response.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id,
+                    result: `0x${chainId.toString(16)}`
+                }));
+            } else if (method === 'eth_call' && canonicalRollup) {
+                registryCalls.push({
+                    to: params[0].to,
+                    data: params[0].data
+                });
+                response.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id,
+                    result: encodeAbiParameters([
+                        {
+                            type: 'address'
+                        }
+                    ], [
+                        canonicalRollup.toString()
+                    ])
+                }));
+            } else {
+                response.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id,
+                    error: {
+                        code: -32601,
+                        message: 'Unsupported method'
+                    }
+                }));
+            }
+        });
+    });
+    await new Promise((resolve)=>server.listen(0, '127.0.0.1', resolve));
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Expected a TCP server address');
+    }
+    return {
+        url: `http://127.0.0.1:${address.port}`,
+        registryCalls,
+        close: ()=>new Promise((resolve)=>server.close(resolve))
+    };
+}

package/dest/cmds/l1/update_l1_validators.d.ts

@@ -9,6 +9,13 @@ export interface RollupCommandArgs {
     rollupAddress: EthAddress;
     withdrawerAddress?: EthAddress;
 }
+/** Credentials and derivation indices for a local Ethereum signer. */
+export type SignerAccountArgs = {
+    privateKey?: string;
+    mnemonic?: string;
+    accountIndex?: number;
+    addressIndex?: number;
+};
 export interface StakingAssetHandlerCommandArgs {
     rpcUrls: string[];
     chainId: number;
@@ -38,15 +45,51 @@ export declare function addL1ValidatorViaRollup({ rpcUrls, chainId, privateKey,
 export declare function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }: RollupCommandArgs & LoggerArgs & {
     validatorAddress: EthAddress;
 }): Promise<void>;
+/** Chain ID and registry published for a network; both are undefined when it publishes none, as for `local`. */
+export type AttesterExitNetwork = {
+    name: string;
+    l1ChainId?: number;
+    registryAddress?: EthAddress;
+};
+/** Loads the published config of the network selected with --network, which takes precedence over the environment. */
+export declare function getAttesterExitNetwork(name: string): Promise<AttesterExitNetwork>;
+/** Inputs that select the chain and rollup an attester exit is signed for; each is undefined when not supplied. */
+export type AttesterExitTargetArgs = {
+    chainId?: number;
+    /** Whether `chainId` came from the L1_CHAIN_ID environment variable rather than a flag. */
+    chainIdFromEnv?: boolean;
+    rpcUrls?: string[];
+    network?: AttesterExitNetwork;
+    rollupAddress?: EthAddress;
+    log: LogFn;
+};
+/**
+ * Resolves the chain ID and rollup an attester exit is signed for, without falling back to the Anvil chain ID.
+ * Whenever an RPC is given, its chain ID must match. Without one, signing is offline and needs the chain ID from a flag
+ * or --network; an L1_CHAIN_ID left in the environment alone is rejected because nothing confirms it.
+ */
+export declare function resolveAttesterExitTarget({ chainId, chainIdFromEnv, rpcUrls, network, rollupAddress, log }: AttesterExitTargetArgs): Promise<{
+    chainId: number;
+    rollupAddress: EthAddress;
+}>;
+/** Signs an exit authorization locally and writes a JSON array accepted by the batch command. */
+export declare function signAttesterExit({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, rollupAddress, attesterAddress, deadline, output, append, log }: Omit<RollupCommandArgs, 'withdrawerAddress' | 'mnemonic' | 'privateKey'> & SignerAccountArgs & {
+    attesterAddress: EthAddress;
+    deadline: bigint;
+    output: string;
+    append?: boolean;
+    log: LogFn;
+}): Promise<void>;
 /** Reads relayed attester exit authorizations from a JSON array. */
 export declare function readAttesterExitAuthorizations(path: string): Promise<AttesterExitAuthorization[]>;
 /** Relays a batch of attester-signed exits. */
-export declare function initiateWithdrawByAttesterBatch({ rpcUrls, chainId, privateKey, mnemonic, authorizations, upToLimit, rollupAddress, log, debugLogger }: Omit<RollupCommandArgs, 'withdrawerAddress'> & LoggerArgs & {
+export declare function initiateWithdrawByAttesterBatch({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, authorizations, upToLimit, dryRun, rollupAddress, log, debugLogger }: Omit<RollupCommandArgs, 'withdrawerAddress' | 'mnemonic' | 'privateKey'> & SignerAccountArgs & LoggerArgs & {
     authorizations: AttesterExitAuthorization[];
     upToLimit: boolean;
-}): Promise<import("viem").TransactionReceipt>;
+    dryRun?: boolean;
+}): Promise<import("viem").TransactionReceipt | undefined>;
 /** Initiates an attester exit without changing the registered withdrawer's control over the payout. */
-export declare function initiateWithdrawByAttester({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, rollupAddress, log, debugLogger }: Omit<RollupCommandArgs, 'withdrawerAddress'> & LoggerArgs & {
+export declare function initiateWithdrawByAttester({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, attesterAddress, rollupAddress, log, debugLogger }: Omit<RollupCommandArgs, 'withdrawerAddress' | 'mnemonic' | 'privateKey'> & SignerAccountArgs & LoggerArgs & {
     attesterAddress: EthAddress;
 }): Promise<import("viem").TransactionReceipt>;
 export declare function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }: RollupCommandArgs & LoggerArgs): Promise<void>;
@@ -54,4 +97,4 @@ export declare function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, num
     numEpochs: bigint;
 }): Promise<void>;
 export declare function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/cmds/l1/update_l1_validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update_l1_validators.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/update_l1_validators.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"update_l1_validators.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/update_l1_validators.ts"],"names":[],"mappings":"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"}

package/dest/cmds/l1/update_l1_validators.js

@@ -1,17 +1,22 @@
 import { RollupAbi, StakingAssetHandlerAbi, TestERC20Abi } from '@aztec-foundation/l1-artifacts';
 import { createEthereumChain, isAnvilTestChain } from '@aztec-labs/ethereum/chain';
-import { createExtendedL1Client, getPublicClient } from '@aztec-labs/ethereum/client';
+import { createExtendedL1Client, getPublicClient, makeL1HttpTransport } from '@aztec-labs/ethereum/client';
 import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
-import { GSEContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import { GSEContract, RegistryContract, RollupContract } from '@aztec-labs/ethereum/contracts';
 import { createL1TxUtils } from '@aztec-labs/ethereum/l1-tx-utils';
 import { EthCheatCodes } from '@aztec-labs/ethereum/test';
+import { getActiveNetworkName } from '@aztec-labs/foundation/config';
 import { EthAddress } from '@aztec-labs/foundation/eth-address';
 import { Signature } from '@aztec-labs/foundation/eth-signature';
 import { DateProvider } from '@aztec-labs/foundation/timer';
 import { ZkPassportProofParams } from '@aztec-labs/stdlib/zkpassport';
-import { readFile } from 'node:fs/promises';
-import { encodeFunctionData, formatEther, getContract, isHex, maxUint256 } from 'viem';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createPublicClient, encodeFunctionData, formatEther, getContract, isHex, maxUint256 } from 'viem';
 import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import { getNetworkConfig } from '../../config/network_config.js';
+import { atomicUpdateFile } from '../../utils/commands.js';
+import { deriveEthAttester } from '../validator_keys/shared.js';
 export function generateL1Account() {
     const privateKey = generatePrivateKey();
     const account = privateKeyToAccount(privateKey);
@@ -191,13 +196,131 @@ export async function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic
     });
     dualLog(`Transaction hash: ${receipt.transactionHash}`);
 }
+/** Loads the published config of the network selected with --network, which takes precedence over the environment. */ export async function getAttesterExitNetwork(name) {
+    const networkName = getActiveNetworkName(name);
+    const cacheDir = process.env.DATA_DIRECTORY ? join(process.env.DATA_DIRECTORY, 'cache') : undefined;
+    const config = networkName === 'local' ? undefined : await getNetworkConfig(networkName, cacheDir);
+    if (networkName !== 'local' && !config) {
+        throw new Error(`Network ${networkName} has no published config`);
+    }
+    return {
+        name: networkName,
+        l1ChainId: config?.l1ChainId,
+        registryAddress: config ? EthAddress.fromString(config.registryAddress) : undefined
+    };
+}
+/**
+ * Resolves the chain ID and rollup an attester exit is signed for, without falling back to the Anvil chain ID.
+ * Whenever an RPC is given, its chain ID must match. Without one, signing is offline and needs the chain ID from a flag
+ * or --network; an L1_CHAIN_ID left in the environment alone is rejected because nothing confirms it.
+ */ export async function resolveAttesterExitTarget({ chainId, chainIdFromEnv = false, rpcUrls, network, rollupAddress, log }) {
+    if (!rollupAddress && !network) {
+        throw new Error('Provide --rollup, or --network to use the canonical rollup from the network registry');
+    }
+    if (!rollupAddress && !network?.registryAddress) {
+        throw new Error(`Network ${network?.name} publishes no registry address; provide --rollup`);
+    }
+    if (chainId !== undefined) {
+        assertValidChainId(chainId);
+        if (network?.l1ChainId !== undefined && chainId !== network.l1ChainId) {
+            throw new Error(`Chain ID ${chainId} does not match ${network.name}, which uses chain ID ${network.l1ChainId}`);
+        }
+    }
+    const expectedChainId = chainId ?? network?.l1ChainId;
+    if (!rpcUrls) {
+        if (expectedChainId === undefined) {
+            throw new Error('Provide --l1-chain-id, --network, or --l1-rpc-urls to select the chain to sign for');
+        }
+        if (!rollupAddress) {
+            throw new Error('Looking up the rollup in the network registry requires --l1-rpc-urls');
+        }
+        if (chainIdFromEnv && network?.l1ChainId === undefined) {
+            throw new Error(`Chain ID ${expectedChainId} comes only from L1_CHAIN_ID; confirm it with --l1-chain-id, --network, or --l1-rpc-urls`);
+        }
+        return {
+            chainId: expectedChainId,
+            rollupAddress
+        };
+    }
+    const rpcChainId = await getL1RpcChainId(rpcUrls, expectedChainId);
+    if (rollupAddress) {
+        return {
+            chainId: rpcChainId,
+            rollupAddress
+        };
+    }
+    const registryAddress = network.registryAddress;
+    const client = getPublicClient({
+        l1RpcUrls: rpcUrls,
+        l1ChainId: rpcChainId
+    });
+    const canonicalRollup = await new RegistryContract(client, registryAddress).getCanonicalAddress();
+    log(`Using canonical rollup ${canonicalRollup} from the ${network.name} registry ${registryAddress}`);
+    return {
+        chainId: rpcChainId,
+        rollupAddress: canonicalRollup
+    };
+}
+/** Returns the chain ID the L1 RPC reports, failing if it differs from `expectedChainId`. */ async function getL1RpcChainId(rpcUrls, expectedChainId) {
+    const rpcChainId = await createPublicClient({
+        transport: makeL1HttpTransport(rpcUrls)
+    }).getChainId();
+    if (expectedChainId !== undefined && rpcChainId !== expectedChainId) {
+        throw new Error(`The L1 RPC reports chain ID ${rpcChainId}, but chain ID ${expectedChainId} was requested`);
+    }
+    return rpcChainId;
+}
+/** Signs an exit authorization locally and writes a JSON array accepted by the batch command. */ export async function signAttesterExit({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, rollupAddress, attesterAddress, deadline, output, append = false, log }) {
+    assertValidChainId(chainId);
+    const account = getSignerAccount({
+        privateKey,
+        mnemonic,
+        accountIndex,
+        addressIndex
+    });
+    if (account.address.toLowerCase() !== attesterAddress.toString().toLowerCase()) {
+        throw new Error('The signing account must match the attester address');
+    }
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+    const rollup = new RollupContract(client, rollupAddress);
+    const authorization = await rollup.createAttesterExitAuthorization(attesterAddress, deadline, (typedData)=>account.signTypedData(typedData));
+    const existingAuthorizations = append ? await readAttesterExitAuthorizationJson(output).catch((error)=>{
+        if (!isRecord(error) || error.code !== 'ENOENT') {
+            throw error;
+        }
+        return undefined;
+    }) : undefined;
+    const authorizations = existingAuthorizations ?? [];
+    authorizations.push({
+        attester: authorization.attester.toString(),
+        deadline: authorization.deadline.toString(),
+        signature: Signature.fromViemSignature(authorization.signature).toString()
+    });
+    const json = JSON.stringify(authorizations, null, 2);
+    if (existingAuthorizations) {
+        await atomicUpdateFile(output, `${json}\n`);
+    } else {
+        await writeFile(output, `${json}\n`, {
+            flag: 'wx'
+        });
+    }
+    log(`Wrote attester exit authorization to ${output}`);
+}
 /** Reads relayed attester exit authorizations from a JSON array. */ export async function readAttesterExitAuthorizations(path) {
-    const parsed = JSON.parse(await readFile(path, 'utf-8'));
-    if (!Array.isArray(parsed) || parsed.length === 0) {
+    const parsed = await readAttesterExitAuthorizationJson(path);
+    if (parsed.length === 0) {
         throw new Error('Attester exit authorization file must contain a non-empty JSON array');
     }
     return parsed.map((value, index)=>parseAttesterExitAuthorization(value, index));
 }
+async function readAttesterExitAuthorizationJson(path) {
+    const parsed = JSON.parse(await readFile(path, 'utf-8'));
+    if (!Array.isArray(parsed)) {
+        throw new Error('Attester exit authorization file must contain a JSON array');
+    }
+    return parsed;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -212,7 +335,7 @@ function parseAttesterExitAuthorization(value, index) {
     if (typeof authorization.deadline !== 'string' || !/^\d+$/.test(authorization.deadline)) {
         throw new Error(`Attester exit authorization ${index} deadline must be a decimal string`);
     }
-    if (typeof authorization.signature !== 'string' || !isHex(authorization.signature)) {
+    if (typeof authorization.signature !== 'string' || !isHex(authorization.signature) || !Signature.isValidString(authorization.signature)) {
         throw new Error(`Attester exit authorization ${index} has an invalid signature`);
     }
     return {
@@ -221,32 +344,73 @@ function parseAttesterExitAuthorization(value, index) {
         signature: Signature.fromString(authorization.signature).toViemSignature()
     };
 }
-/** Relays a batch of attester-signed exits. */ export async function initiateWithdrawByAttesterBatch({ rpcUrls, chainId, privateKey, mnemonic, authorizations, upToLimit, rollupAddress, log, debugLogger }) {
-    const account = getAccount(privateKey, mnemonic);
-    const chain = createEthereumChain(rpcUrls, chainId);
-    const client = createExtendedL1Client(rpcUrls, account, chain.chainInfo);
+/**
+ * Confirms the RPC is on the requested chain, then checks each imported signature so a bad entry is named rather than
+ * reverting the whole batch. Duplicates and deadlines are left to the chain, which with --up-to-limit never looks past
+ * the processed prefix.
+ */ async function checkAttesterExitBatch(rollup, authorizations, rpcUrls, chainId) {
+    await getL1RpcChainId(rpcUrls, chainId);
+    for (const [index, authorization] of authorizations.entries()){
+        await rollup.validateAttesterExitSignature(authorization, index);
+    }
+}
+/** Relays a batch of attester-signed exits. */ export async function initiateWithdrawByAttesterBatch({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, authorizations, upToLimit, dryRun = false, rollupAddress, log, debugLogger }) {
+    if (dryRun) {
+        assertValidChainId(chainId);
+        // A dry run needs no key, but check any signer options given so the same command can later run without --dry-run.
+        if (privateKey || mnemonic || accountIndex !== undefined || addressIndex !== undefined) {
+            getSignerAccount({
+                privateKey,
+                mnemonic,
+                accountIndex,
+                addressIndex
+            });
+        }
+        const client = getPublicClient({
+            l1RpcUrls: rpcUrls,
+            l1ChainId: chainId
+        });
+        const rollup = new RollupContract(client, rollupAddress);
+        await checkAttesterExitBatch(rollup, authorizations, rpcUrls, chainId);
+        const processedCount = await rollup.simulateAttesterExitBatch(authorizations, upToLimit);
+        log(`Dry run: would process ${processedCount} of ${authorizations.length} attester exit authorizations at current chain state.`);
+        logRemainingAttesterExits(log, processedCount, authorizations.length);
+        return;
+    }
+    const account = getSignerAccount({
+        privateKey,
+        mnemonic,
+        accountIndex,
+        addressIndex
+    });
+    const client = createExtendedL1Client(rpcUrls, account, createEthereumChain(rpcUrls, chainId).chainInfo);
     const rollup = new RollupContract(client, rollupAddress);
+    await checkAttesterExitBatch(rollup, authorizations, rpcUrls, chainId);
     const l1TxUtils = createL1TxUtils(client, {
         logger: debugLogger
     });
-    const { receipt } = upToLimit ? await rollup.initiateWithdrawByAttesterBatchUpToLimit(l1TxUtils, authorizations) : await rollup.initiateWithdrawByAttesterBatch(l1TxUtils, authorizations);
-    if (receipt.status !== 'success') {
-        throw new Error(`Attester exit batch reverted: ${receipt.transactionHash}`);
-    }
-    log(`Submitted ${authorizations.length} attester exit authorizations. Transaction hash: ${receipt.transactionHash}`);
-    if (upToLimit) {
-        log('The rollup processed the largest permitted prefix of the authorization list.');
-    }
-    debugLogger.info('Attester exit batch submitted', {
+    const { receipt, processedCount, remainingCount } = await rollup.submitAttesterExitBatch(l1TxUtils, authorizations, upToLimit);
+    log(`Processed ${processedCount} of ${authorizations.length} attester exit authorizations. Transaction hash: ${receipt.transactionHash}`);
+    logRemainingAttesterExits(log, processedCount, authorizations.length);
+    debugLogger.info('Attester exit batch processed', {
         authorizationCount: authorizations.length,
+        processedCount,
+        remainingCount,
+        remainingStartIndex: remainingCount > 0 ? processedCount : undefined,
+        remainingEndIndexExclusive: remainingCount > 0 ? authorizations.length : undefined,
         upToLimit,
         rollup: rollupAddress.toString(),
         transactionHash: receipt.transactionHash
     });
     return receipt;
 }
-/** Initiates an attester exit without changing the registered withdrawer's control over the payout. */ export async function initiateWithdrawByAttester({ rpcUrls, chainId, privateKey, mnemonic, attesterAddress, rollupAddress, log, debugLogger }) {
-    const account = getAccount(privateKey, mnemonic);
+/** Initiates an attester exit without changing the registered withdrawer's control over the payout. */ export async function initiateWithdrawByAttester({ rpcUrls, chainId, privateKey, mnemonic, accountIndex, addressIndex, attesterAddress, rollupAddress, log, debugLogger }) {
+    const account = getSignerAccount({
+        privateKey,
+        mnemonic,
+        accountIndex,
+        addressIndex
+    });
     if (account.address.toLowerCase() !== attesterAddress.toString().toLowerCase()) {
         throw new Error('The transaction signer must match the attester address');
     }
@@ -346,12 +510,42 @@ export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }) {
     const proposer = await rollup.getProposerAt(nextBlockTS);
     log(`Proposer NOW: ${proposer.toString()}`);
 }
+function logRemainingAttesterExits(log, processedCount, authorizationCount) {
+    const remainingCount = authorizationCount - processedCount;
+    log(remainingCount > 0 ? `Remaining authorizations: ${remainingCount}. Zero-based JSON array indices ${processedCount} through ${authorizationCount - 1} (inclusive).` : 'Remaining authorizations: 0 (none).');
+}
 function makeDualLog(log, debugLogger) {
     return (msg)=>{
         log(msg);
         debugLogger.info(msg);
     };
 }
+/** `createEthereumChain` maps a falsy chain ID to Anvil, so reject it before a chain is built from it. */ function assertValidChainId(chainId) {
+    if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+        throw new Error('Chain ID must be a positive safe integer');
+    }
+}
+function getSignerAccount({ privateKey, mnemonic, accountIndex, addressIndex }) {
+    if (Boolean(privateKey) === Boolean(mnemonic)) {
+        throw new Error('Provide either a private key or a mnemonic for the signer');
+    }
+    if (privateKey) {
+        if (accountIndex !== undefined || addressIndex !== undefined) {
+            throw new Error('Account and address indices require a mnemonic');
+        }
+        return getAccount(privateKey, undefined);
+    }
+    const selectedAccountIndex = accountIndex ?? 0;
+    const selectedAddressIndex = addressIndex ?? 0;
+    if (!Number.isSafeInteger(selectedAccountIndex) || selectedAccountIndex < 0 || !Number.isSafeInteger(selectedAddressIndex) || selectedAddressIndex < 0) {
+        throw new Error('Account and address indices must be non-negative safe integers');
+    }
+    const derivedKey = deriveEthAttester(mnemonic, selectedAccountIndex, selectedAddressIndex);
+    if (typeof derivedKey !== 'string') {
+        throw new Error('Expected a local signer private key');
+    }
+    return privateKeyToAccount(derivedKey);
+}
 function getAccount(privateKey, mnemonic) {
     if (!privateKey && !mnemonic) {
         throw new Error('Either privateKey or mnemonic must be provided to create a wallet client');