@aztec/cli 0.0.0-test.0

package/dest/cmds/l1/deploy_l1_verifier.js

@@ -0,0 +1,54 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import { HonkVerifierAbi, HonkVerifierBytecode } from '@aztec/l1-artifacts';
+import { InvalidOptionArgumentError } from 'commander';
+import { getContract } from 'viem';
+export async function deployUltraHonkVerifier(rollupAddress, ethRpcUrls, l1ChainId, privateKey, mnemonic, pxeRpcUrl, bbBinaryPath, bbWorkingDirectory, log, debugLogger) {
+    if (!bbBinaryPath || !bbWorkingDirectory) {
+        throw new InvalidOptionArgumentError('Missing path to bb binary and working directory');
+    }
+    const { publicClient, walletClient } = createL1Clients(ethRpcUrls, privateKey ?? mnemonic, createEthereumChain(ethRpcUrls, l1ChainId).chainInfo);
+    if (!rollupAddress && pxeRpcUrl) {
+        const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+        const { l1ContractAddresses } = await pxe.getNodeInfo();
+        rollupAddress = l1ContractAddresses.rollupAddress.toString();
+    }
+    if (!rollupAddress) {
+        throw new InvalidOptionArgumentError('Missing rollup address');
+    }
+    const { RollupAbi } = await import('@aztec/l1-artifacts');
+    const rollup = getContract({
+        abi: RollupAbi,
+        address: rollupAddress,
+        client: walletClient
+    });
+    const { address: verifierAddress } = await deployL1Contract(walletClient, publicClient, HonkVerifierAbi, HonkVerifierBytecode);
+    log(`Deployed honk verifier at ${verifierAddress}`);
+    await rollup.write.setEpochVerifier([
+        verifierAddress.toString()
+    ]);
+    log(`Rollup accepts only real proofs now`);
+}
+export async function deployMockVerifier(rollupAddress, ethRpcUrls, l1ChainId, privateKey, mnemonic, pxeRpcUrl, log, debugLogger) {
+    const { publicClient, walletClient } = createL1Clients(ethRpcUrls, privateKey ?? mnemonic, createEthereumChain(ethRpcUrls, l1ChainId).chainInfo);
+    const { MockVerifierAbi, MockVerifierBytecode, RollupAbi } = await import('@aztec/l1-artifacts');
+    const { address: mockVerifierAddress } = await deployL1Contract(walletClient, publicClient, MockVerifierAbi, MockVerifierBytecode);
+    log(`Deployed MockVerifier at ${mockVerifierAddress.toString()}`);
+    if (!rollupAddress && pxeRpcUrl) {
+        const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+        const { l1ContractAddresses } = await pxe.getNodeInfo();
+        rollupAddress = l1ContractAddresses.rollupAddress.toString();
+    }
+    if (!rollupAddress) {
+        throw new InvalidOptionArgumentError('Missing rollup address');
+    }
+    const rollup = getContract({
+        abi: RollupAbi,
+        address: rollupAddress,
+        client: walletClient
+    });
+    await rollup.write.setEpochVerifier([
+        mockVerifierAddress.toString()
+    ]);
+    log(`Rollup accepts only fake proofs now`);
+}

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

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function deployNewRollup(registryAddress: EthAddress, rpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mnemonicIndex: number, salt: number | undefined, testAccounts: boolean, json: boolean, initialValidators: EthAddress[], log: LogFn, debugLogger: Logger): Promise<void>;
+//# sourceMappingURL=deploy_new_rollup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_new_rollup.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/deploy_new_rollup.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAK3D,wBAAsB,eAAe,CACnC,eAAe,EAAE,UAAU,EAC3B,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,YAAY,EAAE,OAAO,EACrB,IAAI,EAAE,OAAO,EACb,iBAAiB,EAAE,UAAU,EAAE,EAC/B,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBAqCpB"}

package/dest/cmds/l1/deploy_new_rollup.js

@@ -0,0 +1,19 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { getGenesisValues } from '@aztec/world-state/testing';
+import { deployNewRollupContracts } from '../../utils/aztec.js';
+export async function deployNewRollup(registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, salt, testAccounts, json, initialValidators, log, debugLogger) {
+    const config = getL1ContractsConfigEnvVars();
+    const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+    const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map((a)=>a.address));
+    const { payloadAddress, rollup } = await deployNewRollupContracts(registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, salt, initialValidators, genesisArchiveRoot, genesisBlockHash, config, debugLogger);
+    if (json) {
+        log(JSON.stringify({
+            payloadAddress: payloadAddress.toString(),
+            rollupAddress: rollup.address
+        }, null, 2));
+    } else {
+        log(`Payload Address: ${payloadAddress.toString()}`);
+        log(`Rollup Address: ${rollup.address}`);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { EthAddress } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function getL1Addresses(registryAddress: EthAddress, rollupVersion: number | bigint | 'canonical', rpcUrls: string[], chainId: number, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=get_l1_addresses.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_l1_addresses.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/get_l1_addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAInD,wBAAsB,cAAc,CAClC,eAAe,EAAE,UAAU,EAC3B,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,EAC5C,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,iBAiBX"}

package/dest/cmds/l1/get_l1_addresses.js

@@ -0,0 +1,18 @@
+import { RegistryContract, createEthereumChain } from '@aztec/ethereum';
+import { createPublicClient, fallback, http } from 'viem';
+export async function getL1Addresses(registryAddress, rollupVersion, rpcUrls, chainId, json, log) {
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(rpcUrls.map((url)=>http(url))),
+        pollingInterval: 100
+    });
+    const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);
+    if (json) {
+        log(JSON.stringify(addresses, null, 2));
+    } else {
+        for (const [key, value] of Object.entries(addresses)){
+            log(`${key}: ${value.toString()}`);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+export declare function getL1Balance(who: EthAddress, token: EthAddress | undefined, l1RpcUrls: string[], chainId: number, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=get_l1_balance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get_l1_balance.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/get_l1_balance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAOnD,wBAAsB,YAAY,CAChC,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EAAE,EACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,KAAK,iBA4BX"}

package/dest/cmds/l1/get_l1_balance.js

@@ -0,0 +1,33 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+import { createPublicClient, fallback, getContract, http } from 'viem';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export async function getL1Balance(who, token, l1RpcUrls, chainId, json, log) {
+    const chain = createEthereumChain(l1RpcUrls, chainId);
+    const publicClient = createPublicClient({
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+    });
+    let balance = 0n;
+    if (token) {
+        const gasL1 = getContract({
+            address: token.toString(),
+            abi: TestERC20Abi,
+            client: publicClient
+        });
+        balance = await gasL1.read.balanceOf([
+            who.toString()
+        ]);
+    } else {
+        balance = await publicClient.getBalance({
+            address: who.toString()
+        });
+    }
+    if (json) {
+        log(prettyPrintJSON({
+            balance
+        }));
+    } else {
+        log(`L1 balance of ${who.toString()} is ${balance.toString()}`);
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+export declare function depositGovernanceTokens({ registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, recipient, amount, debugLogger, mint, }: {
+    registryAddress: `0x${string}`;
+    rpcUrls: string[];
+    chainId: number;
+    privateKey: string | undefined;
+    mnemonic: string;
+    mnemonicIndex: number;
+    recipient: `0x${string}`;
+    amount: bigint;
+    debugLogger: Logger;
+    mint: boolean;
+}): Promise<void>;
+export declare function proposeWithLock({ payloadAddress, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, json, debugLogger, log, }: {
+    payloadAddress: `0x${string}`;
+    registryAddress: `0x${string}`;
+    rpcUrls: string[];
+    chainId: number;
+    privateKey: string | undefined;
+    mnemonic: string;
+    mnemonicIndex: number;
+    debugLogger: Logger;
+    log: LogFn;
+    json: boolean;
+}): Promise<void>;
+export declare function voteOnGovernanceProposal({ proposalId, voteAmount, inFavor, waitTilActive, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger, }: {
+    proposalId: bigint;
+    voteAmount: bigint | undefined;
+    inFavor: boolean;
+    waitTilActive: boolean;
+    registryAddress: `0x${string}`;
+    rpcUrls: string[];
+    chainId: number;
+    privateKey: string | undefined;
+    mnemonic: string;
+    mnemonicIndex: number;
+    debugLogger: Logger;
+}): Promise<void>;
+export declare function executeGovernanceProposal({ proposalId, waitTilExecutable, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger, }: {
+    proposalId: bigint;
+    waitTilExecutable: boolean;
+    registryAddress: `0x${string}`;
+    rpcUrls: string[];
+    chainId: number;
+    privateKey: string | undefined;
+    mnemonic: string;
+    mnemonicIndex: number;
+    debugLogger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=governance_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governance_utils.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/governance_utils.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,wBAAsB,uBAAuB,CAAC,EAC5C,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,SAAS,EACT,MAAM,EACN,WAAW,EACX,IAAI,GACL,EAAE;IACD,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,KAAK,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,iBA0BA;AAED,wBAAsB,eAAe,CAAC,EACpC,cAAc,EACd,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,IAAI,EACJ,WAAW,EACX,GAAG,GACJ,EAAE;IACD,cAAc,EAAE,KAAK,MAAM,EAAE,CAAC;IAC9B,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,KAAK,CAAC;IACX,IAAI,EAAE,OAAO,CAAC;CACf,iBAoBA;AAED,wBAAsB,wBAAwB,CAAC,EAC7C,UAAU,EACV,UAAU,EACV,OAAO,EACP,aAAa,EACb,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,WAAW,GACZ,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,iBAmBA;AAED,wBAAsB,yBAAyB,CAAC,EAC9C,UAAU,EACV,iBAAiB,EACjB,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,WAAW,GACZ,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,KAAK,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,iBAiBA"}

package/dest/cmds/l1/governance_utils.js

@@ -0,0 +1,85 @@
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract, createEthereumChain, createL1Clients } from '@aztec/ethereum';
+export async function depositGovernanceTokens({ registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, recipient, amount, debugLogger, mint }) {
+    debugLogger.info(`Depositing ${amount} governance tokens to ${recipient}`);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const { publicClient, walletClient } = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const tokenAddress = addresses.feeJuiceAddress.toString();
+    const feeJuice = new FeeJuiceContract(tokenAddress, publicClient, walletClient);
+    const governance = new GovernanceContract(governanceAddress, publicClient, walletClient);
+    if (mint) {
+        await feeJuice.mint(recipient, amount);
+        debugLogger.info(`Minted ${amount} tokens to ${recipient}`);
+    }
+    await feeJuice.approve(governanceAddress, amount);
+    debugLogger.info(`Approved ${amount} tokens for governance`);
+    await governance.deposit(recipient, amount);
+    debugLogger.info(`Deposited ${amount} tokens to ${recipient}`);
+}
+export async function proposeWithLock({ payloadAddress, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, json, debugLogger, log }) {
+    debugLogger.info(`Proposing with lock from ${payloadAddress} to ${registryAddress}`);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+    const proposalId = await governance.proposeWithLock({
+        payloadAddress,
+        withdrawAddress: clients.walletClient.account.address
+    });
+    if (json) {
+        log(JSON.stringify({
+            proposalId
+        }, null, 2));
+    } else {
+        log(`Proposed with lock`);
+        log(`Proposal ID: ${proposalId}`);
+    }
+}
+export async function voteOnGovernanceProposal({ proposalId, voteAmount, inFavor, waitTilActive, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger }) {
+    debugLogger.info(`Voting on proposal ${proposalId} with ${voteAmount ? voteAmount : 'all'} tokens in favor: ${inFavor}`);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+    const state = await governance.getProposalState(proposalId);
+    if (state !== ProposalState.Active && !waitTilActive) {
+        debugLogger.warn(`Proposal is not active, but waitTilActive is false. Not voting.`);
+        return;
+    }
+    await governance.awaitProposalActive({
+        proposalId,
+        logger: debugLogger
+    });
+    await governance.vote({
+        proposalId,
+        voteAmount,
+        inFavor,
+        retries: 10,
+        logger: debugLogger
+    });
+}
+export async function executeGovernanceProposal({ proposalId, waitTilExecutable, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger }) {
+    debugLogger.info(`Executing proposal ${proposalId}`);
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const clients = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(clients.publicClient, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+    const state = await governance.getProposalState(proposalId);
+    if (state !== ProposalState.Executable && !waitTilExecutable) {
+        debugLogger.warn(`Proposal is not executable, but waitTilExecutable is false. Not executing.`);
+        return;
+    }
+    await governance.awaitProposalExecutable({
+        proposalId,
+        logger: debugLogger
+    });
+    await governance.executeProposal({
+        proposalId,
+        retries: 10,
+        logger: debugLogger
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { type Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAsBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAohB/E"}

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').option('--accelerated-test-deployments', 'Fire and forget deployment transactions, use in testing only', false).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.acceleratedTestDeployments, 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"}