@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/dest/cmds/l1/index.js

@@ -0,0 +1,208 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Option } from 'commander';
+import { ETHEREUM_HOSTS, PRIVATE_KEY, l1ChainIdOption, makePxeOption, parseAztecAddress, parseBigint, parseEthereumAddress, pxeOption } 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()));
+export function injectCommands(program, log, debugLogger) {
+    const { BB_BINARY_PATH, BB_WORKING_DIRECTORY } = process.env;
+    program.command('deploy-l1-contracts').description('Deploys all necessary Ethereum contracts for Aztec.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--validators <string>', 'Comma separated list of validators').option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use in deployment', (arg)=>parseInt(arg), 0).addOption(l1ChainIdOption).option('--salt <number>', 'The optional salt to use in deployment', (arg)=>parseInt(arg)).option('--json', 'Output the contract addresses in JSON format').option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts').action(async (options)=>{
+        const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
+        const initialValidators = options.validators?.split(',').map((validator)=>EthAddress.fromString(validator)) || [];
+        await deployL1Contracts(options.l1RpcUrls, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.salt, options.testAccounts, options.json, initialValidators, log, debugLogger);
+    });
+    program.command('deploy-new-rollup').description('Deploys a new rollup contract and a payload to upgrade the registry with it.').requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--validators <string>', 'Comma separated list of validators').option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use in deployment', (arg)=>parseInt(arg), 0).addOption(l1ChainIdOption).option('--salt <number>', 'The optional salt to use in deployment', (arg)=>parseInt(arg)).option('--json', 'Output the contract addresses in JSON format').option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts').action(async (options)=>{
+        const { deployNewRollup } = await import('./deploy_new_rollup.js');
+        const initialValidators = options.validators?.split(',').map((validator)=>EthAddress.fromString(validator)) || [];
+        await deployNewRollup(options.registryAddress, options.l1RpcUrls, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.salt, options.testAccounts, options.json, initialValidators, log, debugLogger);
+    });
+    program.command('deposit-governance-tokens').description('Deposits governance tokens to the governance contract.').requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).requiredOption('--recipient <string>', 'The recipient of the tokens', parseEthereumAddress).requiredOption('-a, --amount <string>', 'The amount of tokens to deposit', parseBigint).option('--mint', 'Mint the tokens on L1', false).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-p, --private-key <string>', 'The private key to use to deposit', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use to deposit', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use to deposit', (arg)=>parseInt(arg), 0).action(async (options)=>{
+        const { depositGovernanceTokens } = await import('./governance_utils.js');
+        await depositGovernanceTokens({
+            registryAddress: options.registryAddress.toString(),
+            recipient: options.recipient.toString(),
+            amount: options.amount,
+            mint: options.mint,
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            mnemonicIndex: options.mnemonicIndex,
+            debugLogger
+        });
+    });
+    program.command('propose-with-lock').description('Makes a proposal to governance with a lock').requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).requiredOption('-p, --payload-address <string>', 'The address of the payload contract', parseEthereumAddress).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-pk, --private-key <string>', 'The private key to use to propose', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use to propose', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use to propose', (arg)=>parseInt(arg), 0).option('--json', 'Output the proposal ID in JSON format').action(async (options)=>{
+        const { proposeWithLock } = await import('./governance_utils.js');
+        await proposeWithLock({
+            payloadAddress: options.payloadAddress.toString(),
+            registryAddress: options.registryAddress.toString(),
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            mnemonicIndex: options.mnemonicIndex,
+            debugLogger: debugLogger,
+            json: options.json,
+            log
+        });
+    });
+    program.command('vote-on-governance-proposal').description('Votes on a governance proposal.').requiredOption('-p, --proposal-id <string>', 'The ID of the proposal', parseBigint).option('-a, --vote-amount <string>', 'The amount of tokens to vote', parseBigint).requiredOption('--in-favor <boolean>', 'Whether to vote in favor of the proposal. Use "yea" for true, any other value for false.', (arg)=>arg === 'yea' || arg === 'true' || arg === '1' || arg === 'yes').requiredOption('--wait <boolean>', 'Whether to wait until the proposal is active', (arg)=>arg === 'true').requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-pk, --private-key <string>', 'The private key to use to vote', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use to vote', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use to vote', (arg)=>parseInt(arg), 0).action(async (options)=>{
+        const { voteOnGovernanceProposal } = await import('./governance_utils.js');
+        await voteOnGovernanceProposal({
+            proposalId: options.proposalId,
+            voteAmount: options.voteAmount,
+            inFavor: options.inFavor,
+            waitTilActive: options.wait,
+            registryAddress: options.registryAddress.toString(),
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            mnemonicIndex: options.mnemonicIndex,
+            debugLogger
+        });
+    });
+    program.command('execute-governance-proposal').description('Executes a governance proposal.').requiredOption('-p, --proposal-id <string>', 'The ID of the proposal', parseBigint).requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).requiredOption('--wait <boolean>', 'Whether to wait until the proposal is executable', (arg)=>arg === 'true').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('-pk, --private-key <string>', 'The private key to use to vote', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use to vote', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use to vote', (arg)=>parseInt(arg), 0).action(async (options)=>{
+        const { executeGovernanceProposal } = await import('./governance_utils.js');
+        await executeGovernanceProposal({
+            proposalId: options.proposalId,
+            registryAddress: options.registryAddress.toString(),
+            waitTilExecutable: options.wait,
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            mnemonicIndex: options.mnemonicIndex,
+            debugLogger
+        });
+    });
+    program.command('get-l1-addresses').description('Gets the addresses of the L1 contracts.').requiredOption('-r, --registry-address <string>', 'The address of the registry contract', parseEthereumAddress).addOption(l1RpcUrlsOption).requiredOption('-v, --rollup-version <number>', 'The version of the rollup', (arg)=>{
+        if (arg === 'canonical' || arg === 'latest' || arg === '') {
+            return 'canonical';
+        }
+        const version = parseInt(arg);
+        if (isNaN(version)) {
+            throw new Error('Invalid rollup version');
+        }
+        return version;
+    }).addOption(l1ChainIdOption).option('--json', 'Output the addresses in JSON format').action(async (options)=>{
+        const { getL1Addresses } = await import('./get_l1_addresses.js');
+        await getL1Addresses(options.registryAddress, options.rollupVersion, options.l1RpcUrls, options.l1ChainId, options.json, log);
+    });
+    program.command('generate-l1-account').description('Generates a new private key for an account on L1.').option('--json', 'Output the private key in JSON format').action(async ()=>{
+        const { generateL1Account } = await import('./update_l1_validators.js');
+        const account = generateL1Account();
+        log(JSON.stringify(account, null, 2));
+    });
+    program.command('add-l1-validator').description('Adds a validator to the L1 rollup contract.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').addOption(l1ChainIdOption).option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress).action(async (options)=>{
+        const { addL1Validator } = await import('./update_l1_validators.js');
+        await addL1Validator({
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            validatorAddress: options.validator,
+            rollupAddress: options.rollup,
+            withdrawerAddress: options.withdrawer,
+            log,
+            debugLogger
+        });
+    });
+    program.command('remove-l1-validator').description('Removes a validator to the L1 rollup contract.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').addOption(l1ChainIdOption).option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).action(async (options)=>{
+        const { removeL1Validator } = await import('./update_l1_validators.js');
+        await removeL1Validator({
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            validatorAddress: options.validator,
+            rollupAddress: options.rollup,
+            log,
+            debugLogger
+        });
+    });
+    program.command('fast-forward-epochs').description('Fast forwards the epoch of the L1 rollup contract.').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).option('--count <number>', 'The number of epochs to fast forward', (arg)=>BigInt(parseInt(arg)), 1n).action(async (options)=>{
+        const { fastForwardEpochs } = await import('./update_l1_validators.js');
+        await fastForwardEpochs({
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            rollupAddress: options.rollup,
+            numEpochs: options.count,
+            log,
+            debugLogger
+        });
+    });
+    program.command('debug-rollup').description('Debugs the rollup contract.').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).action(async (options)=>{
+        const { debugRollup } = await import('./update_l1_validators.js');
+        await debugRollup({
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            rollupAddress: options.rollup,
+            log,
+            debugLogger
+        });
+    });
+    program.command('prune-rollup').description('Prunes the pending chain on the rollup contract.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').addOption(l1ChainIdOption).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).action(async (options)=>{
+        const { pruneRollup } = await import('./update_l1_validators.js');
+        await pruneRollup({
+            rpcUrls: options.rpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            rollupAddress: options.rollup,
+            log,
+            debugLogger
+        });
+    });
+    program.command('deploy-l1-verifier').description('Deploys the rollup verifier contract').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).addOption(makePxeOption(false).conflicts('rollup-address')).addOption(new Option('--rollup-address <string>', 'The address of the rollup contract').env('ROLLUP_CONTRACT_ADDRESS').argParser(parseEthereumAddress).conflicts('rpc-url')).option('--l1-private-key <string>', 'The L1 private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').requiredOption('--verifier <verifier>', 'Either mock or real', 'real').option('--bb <path>', 'Path to bb binary', BB_BINARY_PATH).option('--bb-working-dir <path>', 'Path to bb working directory', BB_WORKING_DIRECTORY).action(async (options)=>{
+        const { deployMockVerifier, deployUltraHonkVerifier } = await import('./deploy_l1_verifier.js');
+        if (options.verifier === 'mock') {
+            await deployMockVerifier(options.rollupAddress?.toString(), options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, log, debugLogger);
+        } else {
+            await deployUltraHonkVerifier(options.rollupAddress?.toString(), options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, options.bb, options.bbWorkingDir, log, debugLogger);
+        }
+    });
+    program.command('bridge-erc20').description('Bridges ERC20 tokens to L2.').argument('<amount>', 'The amount of Fee Juice to mint and bridge.', parseBigint).argument('<recipient>', 'Aztec address of the recipient.', parseAztecAddress).addOption(l1RpcUrlsOption).option('-m, --mnemonic <string>', 'The mnemonic to use for deriving the Ethereum address that will mint and bridge', 'test test test test test test test test test test test junk').option('--mint', 'Mint the tokens on L1', false).option('--private', 'If the bridge should use the private flow', false).addOption(l1ChainIdOption).requiredOption('-t, --token <string>', 'The address of the token to bridge', parseEthereumAddress).requiredOption('-p, --portal <string>', 'The address of the portal contract', parseEthereumAddress).option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--json', 'Output the claim in JSON format').action(async (amount, recipient, options)=>{
+        const { bridgeERC20 } = await import('./bridge_erc20.js');
+        await bridgeERC20(amount, recipient, options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.token, options.portal, options.private, options.mint, options.json, log, debugLogger);
+    });
+    program.command('create-l1-account').option('--json', 'Output the account in JSON format').action(async (options)=>{
+        const { createL1Account } = await import('./create_l1_account.js');
+        createL1Account(options.json, log);
+    });
+    program.command('get-l1-balance').description('Gets the balance of an ERC token in L1 for the given Ethereum address.').argument('<who>', 'Ethereum address to check.', parseEthereumAddress).addOption(l1RpcUrlsOption).option('-t, --token <string>', 'The address of the token to check the balance of', parseEthereumAddress).addOption(l1ChainIdOption).option('--json', 'Output the balance in JSON format').action(async (who, options)=>{
+        const { getL1Balance } = await import('./get_l1_balance.js');
+        await getL1Balance(who, options.token, options.l1RpcUrls, options.l1ChainId, options.json, log);
+    });
+    program.command('set-proven-through', {
+        hidden: true
+    }).description('Instructs the L1 rollup contract to assume all blocks until the given number are automatically proven.').argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint).addOption(l1RpcUrlsOption).addOption(pxeOption).action(async (blockNumber, options)=>{
+        const { assumeProvenThrough } = await import('./assume_proven_through.js');
+        await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
+    });
+    program.command('advance-epoch').description('Use L1 cheat codes to warp time until the next epoch.').addOption(l1RpcUrlsOption).addOption(pxeOption).action(async (options)=>{
+        const { advanceEpoch } = await import('./advance_epoch.js');
+        await advanceEpoch(options.l1RpcUrls, options.rpcUrl, log);
+    });
+    program.command('prover-stats', {
+        hidden: true
+    }).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('--start-block <number>', 'The L1 block number to start from', parseBigint, 1n).option('--end-block <number>', 'The last L1 block number to query', parseBigint).option('--batch-size <number>', 'The number of blocks to query in each batch', parseBigint, 100n).option('--proving-timeout <number>', 'Cutoff for proving time to consider a block', parseBigint).option('--l1-rollup-address <string>', 'Address of the rollup contract (required if node URL is not set)').option('--node-url <string>', 'JSON RPC URL of an Aztec node to retrieve the rollup contract address (required if L1 rollup address is not set)').option('--raw-logs', 'Output raw logs instead of aggregated stats').action(async (options)=>{
+        const { proverStats } = await import('./prover_stats.js');
+        const { l1RpcUrls, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } = options;
+        await proverStats({
+            l1RpcUrls,
+            chainId,
+            l1RollupAddress,
+            startBlock,
+            endBlock,
+            batchSize,
+            nodeUrl,
+            provingTimeout,
+            rawLogs,
+            log
+        });
+    });
+    return program;
+}

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

@@ -0,0 +1,14 @@
+import { type LogFn } from '@aztec/foundation/log';
+export declare function proverStats(opts: {
+    l1RpcUrls: string[];
+    chainId: number;
+    l1RollupAddress: string | undefined;
+    nodeUrl: string | undefined;
+    log: LogFn;
+    startBlock: bigint;
+    endBlock: bigint | undefined;
+    batchSize: bigint;
+    provingTimeout: bigint | undefined;
+    rawLogs: boolean;
+}): Promise<void>;
+//# sourceMappingURL=prover_stats.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prover_stats.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/prover_stats.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,KAAK,EAA6B,MAAM,uBAAuB,CAAC;AAQ9E,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACtC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,GAAG,EAAE,KAAK,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,OAAO,EAAE,OAAO,CAAC;CAClB,iBAgIA"}

package/dest/cmds/l1/prover_stats.js

@@ -0,0 +1,145 @@
+import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
+import { createEthereumChain } from '@aztec/ethereum';
+import { compactArray, mapValues, unique } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { RollupAbi } from '@aztec/l1-artifacts';
+import { createAztecNodeClient } from '@aztec/stdlib/interfaces/client';
+import chunk from 'lodash.chunk';
+import groupBy from 'lodash.groupby';
+import { createPublicClient, fallback, getAbiItem, getAddress, http } from 'viem';
+export async function proverStats(opts) {
+    const debugLog = createLogger('cli:prover_stats');
+    const { startBlock, chainId, l1RpcUrls, l1RollupAddress, batchSize, nodeUrl, provingTimeout, endBlock, rawLogs, log } = opts;
+    if (!l1RollupAddress && !nodeUrl) {
+        throw new Error('Either L1 rollup address or node URL must be set');
+    }
+    const rollup = l1RollupAddress ? EthAddress.fromString(l1RollupAddress) : await createAztecNodeClient(nodeUrl).getL1ContractAddresses().then((a)=>a.rollupAddress);
+    const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
+    const publicClient = createPublicClient({
+        chain,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    });
+    const lastBlockNum = endBlock ?? await publicClient.getBlockNumber();
+    debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
+    // Get all events for L2 proof submissions
+    const events = await getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+    // If we only care for raw logs, output them
+    if (rawLogs && !provingTimeout) {
+        log(`l1_block_number, l2_block_number, prover_id, tx_hash`);
+        for (const event of events){
+            const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
+            log(`${l1BlockNumber}, ${l2BlockNumber}, ${proverId}, ${txHash}`);
+        }
+        return;
+    }
+    // If we don't have a proving timeout, we can just count the number of unique blocks per prover
+    if (!provingTimeout) {
+        const stats = groupBy(events, 'proverId');
+        log(`prover_id, total_blocks_proven`);
+        for(const proverId in stats){
+            const uniqueBlocks = new Set(stats[proverId].map((e)=>e.l2BlockNumber));
+            log(`${proverId}, ${uniqueBlocks.size}`);
+        }
+        return;
+    }
+    // But if we do, fetch the events for each block submitted, so we can look up their timestamp
+    const blockEvents = await getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+    debugLog.verbose(`First L2 block within range is ${blockEvents[0]?.args.blockNumber} at L1 block ${blockEvents[0]?.blockNumber}`);
+    // Get the timestamps for every block on every log, both for proof and block submissions
+    const l1BlockNumbers = unique([
+        ...events.map((e)=>e.l1BlockNumber),
+        ...blockEvents.map((e)=>e.blockNumber)
+    ]);
+    const l1BlockTimestamps = {};
+    for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))){
+        const blocks = await Promise.all(l1Batch.map((blockNumber)=>publicClient.getBlock({
+                includeTransactions: false,
+                blockNumber
+            })));
+        debugLog.verbose(`Queried ${blocks.length} L1 blocks between ${l1Batch[0]} and ${l1Batch[l1Batch.length - 1]}`);
+        for (const block of blocks){
+            l1BlockTimestamps[block.number.toString()] = block.timestamp;
+        }
+    }
+    // Map from l2 block number to the l1 block in which it was submitted
+    const l2BlockSubmissions = {};
+    for (const blockEvent of blockEvents){
+        l2BlockSubmissions[blockEvent.args.blockNumber.toString()] = blockEvent.blockNumber;
+    }
+    // If we want raw logs, output them
+    if (rawLogs) {
+        log(`l1_block_number, l2_block_number, l2_block_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+        for (const event of events){
+            const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
+            const uploadedBlockNumber = l2BlockSubmissions[l2BlockNumber.toString()];
+            if (!uploadedBlockNumber) {
+                continue;
+            }
+            const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+            const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
+            log(`${l1BlockNumber}, ${l2BlockNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+        }
+        return;
+    }
+    // Or calculate stats per prover
+    const stats = mapValues(groupBy(events, 'proverId'), (blocks, proverId)=>compactArray(blocks.map((e)=>{
+            const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
+            const uploadedBlockNumber = l2BlockSubmissions[e.l2BlockNumber.toString()];
+            if (!uploadedBlockNumber) {
+                debugLog.verbose(`Skipping ${proverId}'s proof for L2 block ${e.l2BlockNumber} as it was before the start block`);
+                return undefined;
+            }
+            const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
+            const provingTime = provenTimestamp - uploadedTimestamp;
+            debugLog.debug(`prover=${e.proverId} blockNumber=${e.l2BlockNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`);
+            return {
+                provenTimestamp,
+                uploadedTimestamp,
+                provingTime,
+                ...e
+            };
+        })));
+    log(`prover_id, blocks_proven_within_timeout, total_blocks_proven, avg_proving_time`);
+    for(const proverId in stats){
+        const blocks = stats[proverId];
+        const withinTimeout = blocks.filter((b)=>b.provingTime <= provingTimeout);
+        const uniqueBlocksWithinTimeout = new Set(withinTimeout.map((e)=>e.l2BlockNumber));
+        const uniqueBlocks = new Set(blocks.map((e)=>e.l2BlockNumber));
+        const avgProvingTime = blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b)=>acc + b.provingTime, 0n)) / blocks.length);
+        log(`${proverId}, ${uniqueBlocksWithinTimeout.size}, ${uniqueBlocks.size}, ${avgProvingTime}`);
+    }
+    return;
+}
+async function getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
+    let blockNum = startBlock;
+    const events = [];
+    while(blockNum <= lastBlockNum){
+        const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+        const newEvents = await retrieveL2ProofVerifiedEvents(publicClient, rollup, blockNum, end);
+        events.push(...newEvents);
+        debugLog.verbose(`Got ${newEvents.length} events querying l2 proof verified from block ${blockNum} to ${end}`);
+        blockNum += batchSize;
+    }
+    return events;
+}
+async function getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
+    let blockNum = startBlock;
+    const events = [];
+    while(blockNum <= lastBlockNum){
+        const end = blockNum + batchSize > lastBlockNum + 1n ? lastBlockNum + 1n : blockNum + batchSize;
+        const newEvents = await publicClient.getLogs({
+            address: getAddress(rollup.toString()),
+            event: getAbiItem({
+                abi: RollupAbi,
+                name: 'L2BlockProposed'
+            }),
+            fromBlock: blockNum,
+            toBlock: end
+        });
+        events.push(...newEvents);
+        debugLog.verbose(`Got ${newEvents.length} events querying l2 block submitted from block ${blockNum} to ${end}`);
+        blockNum += batchSize;
+    }
+    return events;
+}

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

@@ -0,0 +1,30 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export interface RollupCommandArgs {
+    rpcUrls: string[];
+    chainId: number;
+    privateKey?: string;
+    mnemonic?: string;
+    rollupAddress: EthAddress;
+    withdrawerAddress?: EthAddress;
+}
+export interface LoggerArgs {
+    log: LogFn;
+    debugLogger: Logger;
+}
+export declare function generateL1Account(): {
+    privateKey: `0x${string}`;
+    address: `0x${string}`;
+};
+export declare function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, withdrawerAddress, log, debugLogger, }: RollupCommandArgs & LoggerArgs & {
+    validatorAddress: EthAddress;
+}): Promise<void>;
+export declare function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger, }: RollupCommandArgs & LoggerArgs & {
+    validatorAddress: EthAddress;
+}): Promise<void>;
+export declare function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger, }: RollupCommandArgs & LoggerArgs): Promise<void>;
+export declare function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, numEpochs, log, debugLogger, }: RollupCommandArgs & LoggerArgs & {
+    numEpochs: bigint;
+}): Promise<void>;
+export declare function debugRollup({ rpcUrls, chainId, rollupAddress, log }: RollupCommandArgs & LoggerArgs): Promise<void>;
+//# sourceMappingURL=update_l1_validators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"update_l1_validators.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/update_l1_validators.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAM3D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,UAAU,CAAC;IAC1B,iBAAiB,CAAC,EAAE,UAAU,CAAC;CAChC;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,KAAK,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,iBAAiB;;;EAQhC;AAED,wBAAsB,cAAc,CAAC,EACnC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,GAAG,EACH,WAAW,GACZ,EAAE,iBAAiB,GAAG,UAAU,GAAG;IAAE,gBAAgB,EAAE,UAAU,CAAA;CAAE,iBA+CnE;AAED,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,GAAG,EACH,WAAW,GACZ,EAAE,iBAAiB,GAAG,UAAU,GAAG;IAAE,gBAAgB,EAAE,UAAU,CAAA;CAAE,iBAcnE;AAED,wBAAsB,WAAW,CAAC,EAChC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,GAAG,EACH,WAAW,GACZ,EAAE,iBAAiB,GAAG,UAAU,iBAchC;AAED,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,OAAO,EACP,aAAa,EACb,SAAS,EACT,GAAG,EACH,WAAW,GACZ,EAAE,iBAAiB,GAAG,UAAU,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,iBAyBxD;AAED,wBAAsB,WAAW,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,EAAE,iBAAiB,GAAG,UAAU,iBA4BzG"}

package/dest/cmds/l1/update_l1_validators.js

@@ -0,0 +1,186 @@
+import { EthCheatCodes, createEthereumChain, getExpectedAddress, getL1ContractsConfigEnvVars, isAnvilTestChain } from '@aztec/ethereum';
+import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+export function generateL1Account() {
+    const privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    account.address;
+    return {
+        privateKey,
+        address: account.address
+    };
+}
+export async function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, withdrawerAddress, log, debugLogger }) {
+    const config = getL1ContractsConfigEnvVars();
+    const dualLog = makeDualLog(log, debugLogger);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient
+    });
+    const stakingAsset = getContract({
+        address: await rollup.read.getStakingAsset(),
+        abi: TestERC20Abi,
+        client: walletClient
+    });
+    await Promise.all([
+        await stakingAsset.write.mint([
+            walletClient.account.address,
+            config.minimumStake
+        ], {}),
+        await stakingAsset.write.approve([
+            rollupAddress.toString(),
+            config.minimumStake
+        ], {})
+    ].map((txHash)=>publicClient.waitForTransactionReceipt({
+            hash: txHash
+        })));
+    dualLog(`Adding validator ${validatorAddress.toString()} to rollup ${rollupAddress.toString()}`);
+    const txHash = await rollup.write.deposit([
+        validatorAddress.toString(),
+        // TODO(#11451): custom forwarders
+        getExpectedAddress(ForwarderAbi, ForwarderBytecode, [
+            validatorAddress.toString()
+        ], validatorAddress.toString()).address,
+        withdrawerAddress?.toString() ?? validatorAddress.toString(),
+        config.minimumStake
+    ]);
+    dualLog(`Transaction hash: ${txHash}`);
+    await publicClient.waitForTransactionReceipt({
+        hash: txHash
+    });
+    if (isAnvilTestChain(chainId)) {
+        dualLog(`Funding validator on L1`);
+        const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
+        await cheatCodes.setBalance(validatorAddress, 10n ** 20n);
+    } else {
+        const balance = await publicClient.getBalance({
+            address: validatorAddress.toString()
+        });
+        const balanceInEth = Number(balance) / 10 ** 18;
+        dualLog(`Validator balance: ${balanceInEth.toFixed(6)} ETH`);
+        if (balanceInEth === 0) {
+            dualLog(`WARNING: Validator has no balance. Remember to fund it!`);
+        }
+    }
+}
+export async function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient
+    });
+    dualLog(`Removing validator ${validatorAddress.toString()} from rollup ${rollupAddress.toString()}`);
+    const txHash = await rollup.write.initiateWithdraw([
+        validatorAddress.toString(),
+        validatorAddress.toString()
+    ]);
+    dualLog(`Transaction hash: ${txHash}`);
+    await publicClient.waitForTransactionReceipt({
+        hash: txHash
+    });
+}
+export async function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient
+    });
+    dualLog(`Trying prune`);
+    const txHash = await rollup.write.prune();
+    dualLog(`Transaction hash: ${txHash}`);
+    await publicClient.waitForTransactionReceipt({
+        hash: txHash
+    });
+}
+export async function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, numEpochs, log, debugLogger }) {
+    const dualLog = makeDualLog(log, debugLogger);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: publicClient
+    });
+    const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
+    const currentSlot = await rollup.read.getCurrentSlot();
+    const l2SlotsInEpoch = await rollup.read.getEpochDuration();
+    const timestamp = await rollup.read.getTimestampForSlot([
+        currentSlot + l2SlotsInEpoch * numEpochs
+    ]);
+    dualLog(`Fast forwarding ${numEpochs} epochs to ${timestamp}`);
+    try {
+        await cheatCodes.warp(Number(timestamp));
+        dualLog(`Fast forwarded ${numEpochs} epochs to ${timestamp}`);
+    } catch (error) {
+        if (error instanceof Error && error.message.includes("is lower than or equal to previous block's timestamp")) {
+            dualLog(`Someone else fast forwarded the chain to a point after/equal to the target time`);
+        } else {
+            // Re-throw other errors
+            throw error;
+        }
+    }
+}
+export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }) {
+    const config = getL1ContractsConfigEnvVars();
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client: publicClient
+    });
+    const pendingNum = await rollup.read.getPendingBlockNumber();
+    log(`Pending block num: ${pendingNum}`);
+    const provenNum = await rollup.read.getProvenBlockNumber();
+    log(`Proven block num: ${provenNum}`);
+    const validators = await rollup.read.getAttesters();
+    log(`Validators: ${validators.map((v)=>v.toString()).join(', ')}`);
+    const committee = await rollup.read.getCurrentEpochCommittee();
+    log(`Committee: ${committee.map((v)=>v.toString()).join(', ')}`);
+    const archive = await rollup.read.archive();
+    log(`Archive: ${archive}`);
+    const epochNum = await rollup.read.getCurrentEpoch();
+    log(`Current epoch: ${epochNum}`);
+    const slot = await rollup.read.getCurrentSlot();
+    log(`Current slot: ${slot}`);
+    const proposerDuringPrevL1Block = await rollup.read.getCurrentProposer();
+    log(`Proposer during previous L1 block: ${proposerDuringPrevL1Block}`);
+    const nextBlockTS = BigInt((await publicClient.getBlock()).timestamp + BigInt(config.ethereumSlotDuration));
+    const proposer = await rollup.read.getProposerAt([
+        nextBlockTS
+    ]);
+    log(`Proposer NOW: ${proposer.toString()}`);
+}
+function makeDualLog(log, debugLogger) {
+    return (msg)=>{
+        log(msg);
+        debugLogger.info(msg);
+    };
+}
+function getPublicClient(rpcUrls, chainId) {
+    const chain = createEthereumChain(rpcUrls, chainId);
+    return createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(rpcUrls.map((url)=>http(url)))
+    });
+}
+function getWalletClient(rpcUrls, chainId, privateKey, mnemonic) {
+    if (!privateKey && !mnemonic) {
+        throw new Error('Either privateKey or mnemonic must be provided to create a wallet client');
+    }
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const account = !privateKey ? mnemonicToAccount(mnemonic) : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}`);
+    return createWalletClient({
+        account,
+        chain: chain.chainInfo,
+        transport: fallback(rpcUrls.map((url)=>http(url)))
+    });
+}

package/dest/cmds/misc/compute_selector.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function computeSelector(functionSignature: string, log: LogFn): Promise<void>;
+//# sourceMappingURL=compute_selector.d.ts.map

package/dest/cmds/misc/compute_selector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_selector.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/compute_selector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,wBAAsB,eAAe,CAAC,iBAAiB,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAG1E"}

package/dest/cmds/misc/compute_selector.js

@@ -0,0 +1,5 @@
+import { FunctionSelector } from '@aztec/stdlib/abi';
+export async function computeSelector(functionSignature, log) {
+    const selector = await FunctionSelector.fromSignature(functionSignature);
+    log(`${selector}`);
+}

package/dest/cmds/misc/example_contracts.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function exampleContracts(log: LogFn): Promise<void>;
+//# sourceMappingURL=example_contracts.d.ts.map

package/dest/cmds/misc/example_contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example_contracts.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/example_contracts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,KAAK,iBAOhD"}

package/dest/cmds/misc/example_contracts.js

@@ -0,0 +1,6 @@
+import { getExampleContractNames } from '../../utils/aztec.js';
+export async function exampleContracts(log) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+    return (await getExampleContractNames()).filter((name)=>name !== 'AvmTest').sort().forEach((name)=>log(name));
+}

package/dest/cmds/misc/generate_bootnode_enr.d.ts

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec/foundation/log';
+export declare function generateEncodedBootnodeENR(privateKey: string, udpAnnounceAddress: string, l1ChainId: number, log: LogFn): Promise<void>;
+//# sourceMappingURL=generate_bootnode_enr.d.ts.map