@aztec/cli 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.77.0-testnet-ignition.21

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,WAkhB/E"}

package/dest/cmds/l1/index.js

@@ -1,22 +1,103 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Option } from 'commander';
-import { ETHEREUM_HOST, PRIVATE_KEY, l1ChainIdOption, makePxeOption, parseAztecAddress, parseBigint, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+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.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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').action(async (options)=>{
+    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.rpcUrl, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.salt, options.json, initialValidators, log, debugLogger);
+        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.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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({
-            rpcUrl: options.rpcUrl,
+            rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
@@ -27,10 +108,10 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('remove-l1-validator').description('Removes a validator to the L1 rollup contract.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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({
-            rpcUrl: options.rpcUrl,
+            rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
@@ -40,10 +121,10 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('fast-forward-epochs').description('Fast forwards the epoch of the L1 rollup contract.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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({
-            rpcUrl: options.rpcUrl,
+            rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             rollupAddress: options.rollup,
             numEpochs: options.count,
@@ -51,10 +132,10 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('debug-rollup').description('Debugs the rollup contract.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).addOption(l1ChainIdOption).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).action(async (options)=>{
+    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({
-            rpcUrl: options.rpcUrl,
+            rpcUrls: options.l1RpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
@@ -63,10 +144,10 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('prune-rollup').description('Prunes the pending chain on the rollup contract.').requiredOption('-u, --rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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({
-            rpcUrl: options.rpcUrl,
+            rpcUrls: options.rpcUrls,
             chainId: options.l1ChainId,
             privateKey: options.privateKey,
             mnemonic: options.mnemonic,
@@ -75,43 +156,43 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('deploy-l1-verifier').description('Deploys the rollup verifier contract').requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).addOption(new Option('--l1-chain-id <string>', 'The chain id of the L1 network').env('L1_CHAIN_ID').default('31337').makeOptionMandatory(true)).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)=>{
+    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.l1RpcUrl, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, log, debugLogger);
+            await deployMockVerifier(options.rollupAddress?.toString(), options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, log, debugLogger);
         } else {
-            await deployUltraHonkVerifier(options.rollupAddress?.toString(), options.l1RpcUrl, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, options.bb, options.bbWorkingDir, log, debugLogger);
+            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).requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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.l1RpcUrl, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.token, options.portal, options.private, options.mint, options.json, log, debugLogger);
+        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).requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    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.l1RpcUrl, options.l1ChainId, options.json, log);
+        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).requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).addOption(pxeOption).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').addOption(l1ChainIdOption).option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).action(async (blockNumber, options)=>{
+    }).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.l1RpcUrl, options.rpcUrl, options.l1ChainId, options.l1PrivateKey, options.mnemonic, log);
+        await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
     });
-    program.command('advance-epoch').description('Use L1 cheat codes to warp time until the next epoch.').requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).addOption(pxeOption).action(async (options)=>{
+    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.l1RpcUrl, options.rpcUrl, log);
+        await advanceEpoch(options.l1RpcUrls, options.rpcUrl, log);
     });
     program.command('prover-stats', {
         hidden: true
-    }).requiredOption('--l1-rpc-url <string>', 'Url of the ethereum host. Chain identifiers localhost and testnet can be used', ETHEREUM_HOST).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)=>{
+    }).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 { l1RpcUrl, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } = options;
+        const { l1RpcUrls, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } = options;
         await proverStats({
-            l1RpcUrl,
+            l1RpcUrls,
             chainId,
             l1RollupAddress,
             startBlock,

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

@@ -1,24 +1,24 @@
 import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
-import { createAztecNodeClient } from '@aztec/circuit-types';
-import { EthAddress } from '@aztec/circuits.js';
 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, getAbiItem, getAddress, http } from 'viem';
+import { createPublicClient, fallback, getAbiItem, getAddress, http } from 'viem';
 export async function proverStats(opts) {
     const debugLog = createLogger('cli:prover_stats');
-    const { startBlock, chainId, l1RpcUrl, l1RollupAddress, batchSize, nodeUrl, provingTimeout, endBlock, rawLogs, log } = opts;
+    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(l1RpcUrl, chainId).chainInfo;
+    const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
     const publicClient = createPublicClient({
         chain,
-        transport: http(l1RpcUrl)
+        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}`);

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

@@ -1,6 +1,6 @@
 import { EthCheatCodes, createEthereumChain, getExpectedAddress, getL1ContractsConfigEnvVars, isAnvilTestChain } from '@aztec/ethereum';
 import { ForwarderAbi, ForwarderBytecode, RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
-import { createPublicClient, createWalletClient, getContract, http } from 'viem';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
 import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 export function generateL1Account() {
     const privateKey = generatePrivateKey();
@@ -11,11 +11,11 @@ export function generateL1Account() {
         address: account.address
     };
 }
-export async function addL1Validator({ rpcUrl, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, withdrawerAddress, log, debugLogger }) {
+export async function addL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, withdrawerAddress, log, debugLogger }) {
     const config = getL1ContractsConfigEnvVars();
     const dualLog = makeDualLog(log, debugLogger);
-    const publicClient = getPublicClient(rpcUrl, chainId);
-    const walletClient = getWalletClient(rpcUrl, chainId, privateKey, mnemonic);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
     const rollup = getContract({
         address: rollupAddress.toString(),
         abi: RollupAbi,
@@ -54,7 +54,7 @@ export async function addL1Validator({ rpcUrl, chainId, privateKey, mnemonic, va
     });
     if (isAnvilTestChain(chainId)) {
         dualLog(`Funding validator on L1`);
-        const cheatCodes = new EthCheatCodes(rpcUrl, debugLogger);
+        const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
         await cheatCodes.setBalance(validatorAddress, 10n ** 20n);
     } else {
         const balance = await publicClient.getBalance({
@@ -67,10 +67,10 @@ export async function addL1Validator({ rpcUrl, chainId, privateKey, mnemonic, va
         }
     }
 }
-export async function removeL1Validator({ rpcUrl, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }) {
+export async function removeL1Validator({ rpcUrls, chainId, privateKey, mnemonic, validatorAddress, rollupAddress, log, debugLogger }) {
     const dualLog = makeDualLog(log, debugLogger);
-    const publicClient = getPublicClient(rpcUrl, chainId);
-    const walletClient = getWalletClient(rpcUrl, chainId, privateKey, mnemonic);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
     const rollup = getContract({
         address: rollupAddress.toString(),
         abi: RollupAbi,
@@ -86,10 +86,10 @@ export async function removeL1Validator({ rpcUrl, chainId, privateKey, mnemonic,
         hash: txHash
     });
 }
-export async function pruneRollup({ rpcUrl, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }) {
+export async function pruneRollup({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log, debugLogger }) {
     const dualLog = makeDualLog(log, debugLogger);
-    const publicClient = getPublicClient(rpcUrl, chainId);
-    const walletClient = getWalletClient(rpcUrl, chainId, privateKey, mnemonic);
+    const publicClient = getPublicClient(rpcUrls, chainId);
+    const walletClient = getWalletClient(rpcUrls, chainId, privateKey, mnemonic);
     const rollup = getContract({
         address: rollupAddress.toString(),
         abi: RollupAbi,
@@ -102,15 +102,15 @@ export async function pruneRollup({ rpcUrl, chainId, privateKey, mnemonic, rollu
         hash: txHash
     });
 }
-export async function fastForwardEpochs({ rpcUrl, chainId, rollupAddress, numEpochs, log, debugLogger }) {
+export async function fastForwardEpochs({ rpcUrls, chainId, rollupAddress, numEpochs, log, debugLogger }) {
     const dualLog = makeDualLog(log, debugLogger);
-    const publicClient = getPublicClient(rpcUrl, chainId);
+    const publicClient = getPublicClient(rpcUrls, chainId);
     const rollup = getContract({
         address: rollupAddress.toString(),
         abi: RollupAbi,
         client: publicClient
     });
-    const cheatCodes = new EthCheatCodes(rpcUrl, debugLogger);
+    const cheatCodes = new EthCheatCodes(rpcUrls, debugLogger);
     const currentSlot = await rollup.read.getCurrentSlot();
     const l2SlotsInEpoch = await rollup.read.getEpochDuration();
     const timestamp = await rollup.read.getTimestampForSlot([
@@ -129,9 +129,9 @@ export async function fastForwardEpochs({ rpcUrl, chainId, rollupAddress, numEpo
         }
     }
 }
-export async function debugRollup({ rpcUrl, chainId, rollupAddress, log }) {
+export async function debugRollup({ rpcUrls, chainId, rollupAddress, log }) {
     const config = getL1ContractsConfigEnvVars();
-    const publicClient = getPublicClient(rpcUrl, chainId);
+    const publicClient = getPublicClient(rpcUrls, chainId);
     const rollup = getContract({
         address: rollupAddress.toString(),
         abi: RollupAbi,
@@ -165,22 +165,22 @@ function makeDualLog(log, debugLogger) {
         debugLogger.info(msg);
     };
 }
-function getPublicClient(rpcUrl, chainId) {
-    const chain = createEthereumChain(rpcUrl, chainId);
+function getPublicClient(rpcUrls, chainId) {
+    const chain = createEthereumChain(rpcUrls, chainId);
     return createPublicClient({
         chain: chain.chainInfo,
-        transport: http(rpcUrl)
+        transport: fallback(rpcUrls.map((url)=>http(url)))
     });
 }
-function getWalletClient(rpcUrl, chainId, privateKey, mnemonic) {
+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(rpcUrl, chainId);
+    const chain = createEthereumChain(rpcUrls, chainId);
     const account = !privateKey ? mnemonicToAccount(mnemonic) : privateKeyToAccount(`${privateKey.startsWith('0x') ? '' : '0x'}${privateKey}`);
     return createWalletClient({
         account,
         chain: chain.chainInfo,
-        transport: http(rpcUrl)
+        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

@@ -1,4 +1,4 @@
-import { FunctionSelector } from '@aztec/foundation/abi';
+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/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

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate_bootnode_enr.d.ts","sourceRoot":"","sources":["../../../src/cmds/misc/generate_bootnode_enr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAGnD,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,KAAK,iBAIX"}

package/dest/cmds/misc/generate_bootnode_enr.js

@@ -0,0 +1,5 @@
+import { createBootnodeENRandPeerId } from '@aztec/p2p/enr';
+export async function generateEncodedBootnodeENR(privateKey, udpAnnounceAddress, l1ChainId, log) {
+    const { enr } = await createBootnodeENRandPeerId(privateKey, udpAnnounceAddress, l1ChainId);
+    log(`ENR: ${enr.encodeTxt()}`);
+}

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

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

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

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