@aztec-labs/cli 6.0.0-nightly.20260829

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

@@ -0,0 +1,3 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function createL1Account(json: boolean, log: LogFn): void;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2wxX2FjY291bnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2NyZWF0ZV9sMV9hY2NvdW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBS3hELHdCQUFnQixlQUFlLENBQUMsSUFBSSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxRQVV4RCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"create_l1_account.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/create_l1_account.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAKxD,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,QAUxD"}

package/dest/cmds/l1/create_l1_account.js

@@ -0,0 +1,15 @@
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import { prettyPrintJSON } from '../../utils/commands.js';
+export function createL1Account(json, log) {
+    const privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    if (json) {
+        log(prettyPrintJSON({
+            privateKey,
+            address: account.address
+        }));
+    } else {
+        log(`Private Key: ${privateKey}`);
+        log(`Address: ${account.address}`);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { EthAddress } from '@aztec-labs/aztec.js/addresses';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+export declare function deployL1ContractsCmd(rpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mnemonicIndex: number, testAccounts: boolean, sponsoredFPC: boolean, json: boolean, initialValidators: EthAddress[], realVerifier: boolean, existingToken: EthAddress | undefined, log: LogFn, debugLogger: Logger): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95X2wxX2NvbnRyYWN0c19jbWQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2RlcGxveV9sMV9jb250cmFjdHNfY21kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBS2pFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQVFoRSx3QkFBc0Isb0JBQW9CLENBQ3hDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFDakIsT0FBTyxFQUFFLE1BQU0sRUFDZixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDOUIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsYUFBYSxFQUFFLE1BQU0sRUFDckIsWUFBWSxFQUFFLE9BQU8sRUFDckIsWUFBWSxFQUFFLE9BQU8sRUFDckIsSUFBSSxFQUFFLE9BQU8sRUFDYixpQkFBaUIsRUFBRSxVQUFVLEVBQUUsRUFDL0IsWUFBWSxFQUFFLE9BQU8sRUFDckIsYUFBYSxFQUFFLFVBQVUsR0FBRyxTQUFTLEVBQ3JDLEdBQUcsRUFBRSxLQUFLLEVBQ1YsV0FBVyxFQUFFLE1BQU0saUJBNkVwQiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy_l1_contracts_cmd.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/deploy_l1_contracts_cmd.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAKjE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAQhE,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,OAAO,EACrB,IAAI,EAAE,OAAO,EACb,iBAAiB,EAAE,UAAU,EAAE,EAC/B,YAAY,EAAE,OAAO,EACrB,aAAa,EAAE,UAAU,GAAG,SAAS,EACrC,GAAG,EAAE,KAAK,EACV,WAAW,EAAE,MAAM,iBA6EpB"}

package/dest/cmds/l1/deploy_l1_contracts_cmd.js

@@ -0,0 +1,80 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { deployAztecL1Contracts } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { getGenesisValues } from '@aztec-labs/world-state/testing';
+import { mnemonicToAccount } from 'viem/accounts';
+import { addLeadingHex } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+export async function deployL1ContractsCmd(rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, testAccounts, sponsoredFPC, json, initialValidators, realVerifier, existingToken, log, debugLogger) {
+    const config = getL1ContractsConfigEnvVars();
+    // Compute initial accounts for genesis (test accounts + sponsored FPC)
+    const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+    const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+    const initialFundedAccounts = initialAccounts.map((a)=>a.address).concat(sponsoredFPCAddress);
+    const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
+    // Get the VK tree root
+    const { getVKTreeRoot } = await import('@aztec-labs/noir-protocol-circuits-types/vk-tree');
+    const vkTreeRoot = getVKTreeRoot();
+    // Get private key (from direct input or mnemonic)
+    let deployerPrivateKey;
+    if (privateKey) {
+        deployerPrivateKey = addLeadingHex(privateKey);
+    } else {
+        const account = mnemonicToAccount(mnemonic, {
+            addressIndex: mnemonicIndex
+        });
+        deployerPrivateKey = `0x${Buffer.from(account.getHdKey().privateKey).toString('hex')}`;
+    }
+    // Prepare validator operators with bn254 keys
+    const initialValidatorOperators = initialValidators.map((a)=>({
+            attester: a,
+            withdrawer: a,
+            bn254SecretKey: new SecretValue(Fr.random().toBigInt())
+        }));
+    debugLogger.info('Deploying L1 contracts via Forge...');
+    // Deploy using l1-contracts Forge scripts
+    const { l1ContractAddresses, rollupVersion } = await deployAztecL1Contracts(rpcUrls[0], deployerPrivateKey, chainId, {
+        // Initial validators to add during deployment
+        initialValidators: initialValidatorOperators,
+        // Genesis config
+        vkTreeRoot,
+        protocolContractsHash,
+        genesisArchiveRoot,
+        // Deployment options
+        realVerifier,
+        ...config,
+        feeJuicePortalInitialBalance: fundingNeeded,
+        existingTokenAddress: existingToken
+    });
+    debugLogger.info('Forge deployment complete', {
+        rollupVersion
+    });
+    if (json) {
+        log(JSON.stringify(Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v])=>[
+                k,
+                v?.toString() ?? 'Not deployed'
+            ])), null, 2));
+    } else {
+        log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+        log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+        log(`GSE Address: ${l1ContractAddresses.gseAddress?.toString()}`);
+        log(`L1 -> L2 Inbox Address: ${l1ContractAddresses.inboxAddress.toString()}`);
+        log(`L2 -> L1 Outbox Address: ${l1ContractAddresses.outboxAddress.toString()}`);
+        log(`Fee Juice Address: ${l1ContractAddresses.feeJuiceAddress.toString()}`);
+        log(`Staking Asset Address: ${l1ContractAddresses.stakingAssetAddress.toString()}`);
+        log(`Fee Juice Portal Address: ${l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+        log(`CoinIssuer Address: ${l1ContractAddresses.coinIssuerAddress.toString()}`);
+        log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
+        log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
+        log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
+        log(`FeeAssetHandler Address: ${l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
+        log(`StakingAssetHandler Address: ${l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
+        log(`ZK Passport Verifier Address: ${l1ContractAddresses.zkPassportVerifierAddress?.toString()}`);
+        log(`Initial funded accounts: ${initialFundedAccounts.map((a)=>a.toString()).join(', ')}`);
+        log(`Initial validators: ${initialValidators.map((a)=>a.toString()).join(', ')}`);
+        log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { Operator } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function deployNewRollup(registryAddress: EthAddress, rpcUrls: string[], chainId: number, privateKey: string | undefined, mnemonic: string, mnemonicIndex: number, testAccounts: boolean, sponsoredFPC: boolean, json: boolean, initialValidators: Operator[], realVerifier: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVwbG95X25ld19yb2xsdXAuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2RlcGxveV9uZXdfcm9sbHVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQy9FLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBTXhELHdCQUFzQixlQUFlLENBQ25DLGVBQWUsRUFBRSxVQUFVLEVBQzNCLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFDakIsT0FBTyxFQUFFLE1BQU0sRUFDZixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsRUFDOUIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsYUFBYSxFQUFFLE1BQU0sRUFDckIsWUFBWSxFQUFFLE9BQU8sRUFDckIsWUFBWSxFQUFFLE9BQU8sRUFDckIsSUFBSSxFQUFFLE9BQU8sRUFDYixpQkFBaUIsRUFBRSxRQUFRLEVBQUUsRUFDN0IsWUFBWSxFQUFFLE9BQU8sRUFDckIsR0FBRyxFQUFFLEtBQUssaUJBMENYIn0=

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,QAAQ,EAAE,MAAM,gDAAgD,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAMxD,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,YAAY,EAAE,OAAO,EACrB,YAAY,EAAE,OAAO,EACrB,IAAI,EAAE,OAAO,EACb,iBAAiB,EAAE,QAAQ,EAAE,EAC7B,YAAY,EAAE,OAAO,EACrB,GAAG,EAAE,KAAK,iBA0CX"}

package/dest/cmds/l1/deploy_new_rollup.js

@@ -0,0 +1,26 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { getGenesisValues } from '@aztec-labs/world-state/testing';
+import { deployNewRollupContracts } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+export async function deployNewRollup(registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, testAccounts, sponsoredFPC, json, initialValidators, realVerifier, log) {
+    const config = getL1ContractsConfigEnvVars();
+    const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+    const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+    const initialFundedAccounts = initialAccounts.map((a)=>a.address).concat(sponsoredFPCAddress);
+    const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
+    const { rollup } = await deployNewRollupContracts(registryAddress, rpcUrls, privateKey, chainId, mnemonic, mnemonicIndex, initialValidators, genesisArchiveRoot, fundingNeeded, config, realVerifier);
+    if (json) {
+        log(JSON.stringify({
+            rollupAddress: rollup.address,
+            initialFundedAccounts: initialFundedAccounts.map((a)=>a.toString()),
+            initialValidators: initialValidators.map((a)=>a.attester.toString()),
+            genesisArchiveRoot: genesisArchiveRoot.toString()
+        }, null, 2));
+    } else {
+        log(`Rollup Address: ${rollup.address}`);
+        log(`Initial funded accounts: ${initialFundedAccounts.map((a)=>a.toString()).join(', ')}`);
+        log(`Initial validators: ${initialValidators.map((a)=>a.attester.toString()).join(', ')}`);
+        log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+    }
+}

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

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

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,gCAAgC,CAAC;AAI5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGxD,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,21 @@
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { RegistryContract } from '@aztec-labs/ethereum/contracts';
+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, {
+                batch: false
+            }))),
+        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-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+export declare function getL1Balance(who: EthAddress, token: EthAddress | undefined, l1RpcUrls: string[], chainId: number, json: boolean, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X2wxX2JhbGFuY2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2dldF9sMV9iYWxhbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBS3hELHdCQUFzQixZQUFZLENBQ2hDLEdBQUcsRUFBRSxVQUFVLEVBQ2YsS0FBSyxFQUFFLFVBQVUsR0FBRyxTQUFTLEVBQzdCLFNBQVMsRUFBRSxNQUFNLEVBQUUsRUFDbkIsT0FBTyxFQUFFLE1BQU0sRUFDZixJQUFJLEVBQUUsT0FBTyxFQUNiLEdBQUcsRUFBRSxLQUFLLGlCQTRCWCJ9

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":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAKxD,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,35 @@
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+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, {
+                batch: false
+            })))
+    });
+    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-labs/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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ292ZXJuYW5jZV91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NtZHMvbDEvZ292ZXJuYW5jZV91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFaEUsd0JBQXNCLHVCQUF1QixDQUFDLEVBQzVDLGVBQWUsRUFDZixPQUFPLEVBQ1AsT0FBTyxFQUNQLFVBQVUsRUFDVixRQUFRLEVBQ1IsYUFBYSxFQUNiLFNBQVMsRUFDVCxNQUFNLEVBQ04sV0FBVyxFQUNYLElBQUksRUFDTCxFQUFFO0lBQ0QsZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDL0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ2xCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsVUFBVSxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDL0IsUUFBUSxFQUFFLE1BQU0sQ0FBQztJQUNqQixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFNBQVMsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0lBQ3pCLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZixXQUFXLEVBQUUsTUFBTSxDQUFDO0lBQ3BCLElBQUksRUFBRSxPQUFPLENBQUM7Q0FDZixpQkEyQkE7QUFFRCx3QkFBc0IsZUFBZSxDQUFDLEVBQ3BDLGNBQWMsRUFDZCxlQUFlLEVBQ2YsT0FBTyxFQUNQLE9BQU8sRUFDUCxVQUFVLEVBQ1YsUUFBUSxFQUNSLGFBQWEsRUFDYixJQUFJLEVBQ0osV0FBVyxFQUNYLEdBQUcsRUFDSixFQUFFO0lBQ0QsY0FBYyxFQUFFLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDOUIsZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDL0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ2xCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsVUFBVSxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDL0IsUUFBUSxFQUFFLE1BQU0sQ0FBQztJQUNqQixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFdBQVcsRUFBRSxNQUFNLENBQUM7SUFDcEIsR0FBRyxFQUFFLEtBQUssQ0FBQztJQUNYLElBQUksRUFBRSxPQUFPLENBQUM7Q0FDZixpQkFvQkE7QUFFRCx3QkFBc0Isd0JBQXdCLENBQUMsRUFDN0MsVUFBVSxFQUNWLFVBQVUsRUFDVixPQUFPLEVBQ1AsYUFBYSxFQUNiLGVBQWUsRUFDZixPQUFPLEVBQ1AsT0FBTyxFQUNQLFVBQVUsRUFDVixRQUFRLEVBQ1IsYUFBYSxFQUNiLFdBQVcsRUFDWixFQUFFO0lBQ0QsVUFBVSxFQUFFLE1BQU0sQ0FBQztJQUNuQixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMvQixPQUFPLEVBQUUsT0FBTyxDQUFDO0lBQ2pCLGFBQWEsRUFBRSxPQUFPLENBQUM7SUFDdkIsZUFBZSxFQUFFLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDL0IsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ2xCLE9BQU8sRUFBRSxNQUFNLENBQUM7SUFDaEIsVUFBVSxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDL0IsUUFBUSxFQUFFLE1BQU0sQ0FBQztJQUNqQixhQUFhLEVBQUUsTUFBTSxDQUFDO0lBQ3RCLFdBQVcsRUFBRSxNQUFNLENBQUM7Q0FDckIsaUJBbUJBO0FBRUQsd0JBQXNCLHlCQUF5QixDQUFDLEVBQzlDLFVBQVUsRUFDVixpQkFBaUIsRUFDakIsZUFBZSxFQUNmLE9BQU8sRUFDUCxPQUFPLEVBQ1AsVUFBVSxFQUNWLFFBQVEsRUFDUixhQUFhLEVBQ2IsV0FBVyxFQUNaLEVBQUU7SUFDRCxVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLGlCQUFpQixFQUFFLE9BQU8sQ0FBQztJQUMzQixlQUFlLEVBQUUsS0FBSyxNQUFNLEVBQUUsQ0FBQztJQUMvQixPQUFPLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDbEIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixVQUFVLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMvQixRQUFRLEVBQUUsTUFBTSxDQUFDO0lBQ2pCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsV0FBVyxFQUFFLE1BQU0sQ0FBQztDQUNyQixpQkFpQkEifQ==

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":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAEhE,wBAAsB,uBAAuB,CAAC,EAC5C,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,SAAS,EACT,MAAM,EACN,WAAW,EACX,IAAI,EACL,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,iBA2BA;AAED,wBAAsB,eAAe,CAAC,EACpC,cAAc,EACd,eAAe,EACf,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,IAAI,EACJ,WAAW,EACX,GAAG,EACJ,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,EACZ,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,EACZ,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,87 @@
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract } from '@aztec-labs/ethereum/contracts';
+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 extendedClient = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const tokenAddress = addresses.stakingAssetAddress.toString();
+    const feeJuice = new FeeJuiceContract(tokenAddress, extendedClient);
+    const governance = new GovernanceContract(governanceAddress, extendedClient);
+    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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, client);
+    const proposalId = await governance.proposeWithLock({
+        payloadAddress,
+        withdrawAddress: client.account.address
+    });
+    if (json) {
+        log(JSON.stringify({
+            proposalId: Number(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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, client);
+    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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+    const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+    const governanceAddress = addresses.governanceAddress.toString();
+    const governance = new GovernanceContract(governanceAddress, client);
+    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-labs/foundation/log';
+import { type Command } from 'commander';
+export declare function injectCommands(program: Command, log: LogFn, debugLogger: Logger): Command;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF1QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBd2QvRSJ9

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":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAuBjD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,WAwd/E"}

package/dest/cmds/l1/index.js

@@ -0,0 +1,201 @@
+import { CheckpointNumber } from '@aztec-labs/foundation/branded-types';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import { Option } from 'commander';
+import { ETHEREUM_HOSTS, MNEMONIC, PRIVATE_KEY, l1ChainIdOption, nodeOption, parseBigint, parseEthereumAddress } from '../../utils/commands.js';
+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()));
+const networkOption = new Option('--network <string>', 'Network to execute against').env('NETWORK');
+export function injectCommands(program, log, debugLogger) {
+    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('--json', 'Output the contract addresses in JSON format').option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts').option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract').option('--real-verifier', 'Deploy the real verifier', false).option('--existing-token <address>', 'Use an existing ERC20 for both fee and staking', parseEthereumAddress).action(async (options)=>{
+        const { deployL1ContractsCmd } = await import('./deploy_l1_contracts_cmd.js');
+        const initialValidators = options.validators?.split(',').map((validator)=>EthAddress.fromString(validator)) || [];
+        await deployL1ContractsCmd(options.l1RpcUrls, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.testAccounts, options.sponsoredFpc, options.json, initialValidators, options.realVerifier, options.existingToken, log, debugLogger);
+    });
+    program.command('deploy-new-rollup').description('Deploys a new rollup contract and adds it to the registry (if you are the owner).').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', MNEMONIC ?? '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('--json', 'Output the contract addresses in JSON format').option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts').option('--sponsored-fpc', 'Populate genesis state with a testing sponsored FPC contract').option('--real-verifier', 'Deploy the real verifier', false).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.testAccounts, options.sponsoredFpc, options.json, initialValidators, options.realVerifier, log);
+    });
+    program.command('compute-genesis-values').description('Computes genesis values (VK tree root, protocol contracts hash, genesis archive root).').addOption(new Option('--test-accounts <boolean>', 'Include initial test accounts in genesis state').env('TEST_ACCOUNTS').argParser((arg)=>arg === 'true')).addOption(new Option('--sponsored-fpc <boolean>', 'Include sponsored FPC contract in genesis state').env('SPONSORED_FPC').argParser((arg)=>arg === 'true')).action(async (options)=>{
+        const { computeGenesisValuesCmd } = await import('./compute_genesis_values.js');
+        await computeGenesisValuesCmd(options.testAccounts, options.sponsoredFpc, log);
+    });
+    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 via a direct deposit.').addOption(l1RpcUrlsOption).addOption(networkOption).option('-pk, --private-key <string>', 'The private key to use sending the transaction', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use sending the transaction', 'test test test test test test test test test test test junk').addOption(l1ChainIdOption).option('--attester <address>', 'ethereum address of the attester', parseEthereumAddress).option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress).option('--bls-secret-key <string>', 'The BN254 scalar field element used as a secret key for BLS signatures. Will be associated with the attester address.', parseBigint).option('--move-with-latest-rollup', 'Whether to move with the latest rollup', true).option('--rollup <string>', 'Rollup contract address', parseEthereumAddress).action(async (options)=>{
+        const { addL1ValidatorViaRollup } = await import('./update_l1_validators.js');
+        let rollupAddress = options.rollup;
+        if (!rollupAddress) {
+            const { getL1RollupAddressFromEnv } = await import('../../config/get_l1_config.js');
+            rollupAddress = await getL1RollupAddressFromEnv(options.l1RpcUrls, options.l1ChainId);
+        }
+        await addL1ValidatorViaRollup({
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            attesterAddress: options.attester,
+            blsSecretKey: options.blsSecretKey,
+            withdrawerAddress: options.withdrawer,
+            rollupAddress,
+            moveWithLatestRollup: options.moveWithLatestRollup,
+            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('trigger-seed-snapshot').description('Triggers a seed snapshot for the next epoch.').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').option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).action(async (options)=>{
+        const { triggerSeedSnapshot } = await import('./trigger_seed_snapshot.js');
+        await triggerSeedSnapshot({
+            rollupAddress: options.rollup,
+            rpcUrls: options.l1RpcUrls,
+            chainId: options.l1ChainId,
+            privateKey: options.privateKey,
+            mnemonic: options.mnemonic,
+            log
+        });
+    });
+    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('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 checkpoint are automatically proven.').argument('[checkpoint]', 'The target checkpoint, defaults to the latest pending checkpoint.', parseBigint).addOption(l1RpcUrlsOption).addOption(nodeOption).action(async (checkpoint, options)=>{
+        const { assumeProvenThrough } = await import('./assume_proven_through.js');
+        await assumeProvenThrough(CheckpointNumber.fromBigInt(checkpoint), options.l1RpcUrls, options.nodeUrl, log);
+    });
+    program.command('advance-epoch').description('Use L1 cheat codes to warp time until the next epoch.').addOption(l1RpcUrlsOption).addOption(nodeOption).action(async (options)=>{
+        const { advanceEpoch } = await import('./advance_epoch.js');
+        await advanceEpoch(options.l1RpcUrls, options.nodeUrl, log);
+    });
+    return program;
+}