@aztec/cli 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/cmds/l1/deploy_new_rollup.js

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

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

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

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

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

package/dest/cmds/l1/get_l1_addresses.js

@@ -1,10 +1,13 @@
-import { RegistryContract, createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { RegistryContract } from '@aztec/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))),
+        transport: fallback(rpcUrls.map((url)=>http(url, {
+                batch: false
+            }))),
         pollingInterval: 100
     });
     const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);

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

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

package/dest/cmds/l1/get_l1_balance.js

@@ -1,4 +1,4 @@
-import { createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
 import { createPublicClient, fallback, getContract, http } from 'viem';
 import { prettyPrintJSON } from '../../utils/commands.js';
@@ -6,7 +6,9 @@ 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)))
+        transport: fallback(l1RpcUrls.map((url)=>http(url, {
+                batch: false
+            })))
     });
     let balance = 0n;
     if (token) {

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

@@ -1,5 +1,5 @@
 import type { LogFn, Logger } from '@aztec/foundation/log';
-export declare function depositGovernanceTokens({ registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, recipient, amount, debugLogger, mint, }: {
+export declare function depositGovernanceTokens({ registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, recipient, amount, debugLogger, mint }: {
     registryAddress: `0x${string}`;
     rpcUrls: string[];
     chainId: number;
@@ -11,7 +11,7 @@ export declare function depositGovernanceTokens({ registryAddress, rpcUrls, chai
     debugLogger: Logger;
     mint: boolean;
 }): Promise<void>;
-export declare function proposeWithLock({ payloadAddress, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, json, debugLogger, log, }: {
+export declare function proposeWithLock({ payloadAddress, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, json, debugLogger, log }: {
     payloadAddress: `0x${string}`;
     registryAddress: `0x${string}`;
     rpcUrls: string[];
@@ -23,7 +23,7 @@ export declare function proposeWithLock({ payloadAddress, registryAddress, rpcUr
     log: LogFn;
     json: boolean;
 }): Promise<void>;
-export declare function voteOnGovernanceProposal({ proposalId, voteAmount, inFavor, waitTilActive, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger, }: {
+export declare function voteOnGovernanceProposal({ proposalId, voteAmount, inFavor, waitTilActive, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger }: {
     proposalId: bigint;
     voteAmount: bigint | undefined;
     inFavor: boolean;
@@ -36,7 +36,7 @@ export declare function voteOnGovernanceProposal({ proposalId, voteAmount, inFav
     mnemonicIndex: number;
     debugLogger: Logger;
 }): Promise<void>;
-export declare function executeGovernanceProposal({ proposalId, waitTilExecutable, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger, }: {
+export declare function executeGovernanceProposal({ proposalId, waitTilExecutable, registryAddress, rpcUrls, chainId, privateKey, mnemonic, mnemonicIndex, debugLogger }: {
     proposalId: bigint;
     waitTilExecutable: boolean;
     registryAddress: `0x${string}`;
@@ -47,4 +47,4 @@ export declare function executeGovernanceProposal({ proposalId, waitTilExecutabl
     mnemonicIndex: number;
     debugLogger: Logger;
 }): Promise<void>;
-//# sourceMappingURL=governance_utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +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"}
+{"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,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,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

@@ -1,13 +1,15 @@
-import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract, createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract } from '@aztec/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 { publicClient, walletClient } = createL1Clients(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, mnemonicIndex);
-    const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress, 'canonical');
+    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.feeJuiceAddress.toString();
-    const feeJuice = new FeeJuiceContract(tokenAddress, publicClient, walletClient);
-    const governance = new GovernanceContract(governanceAddress, publicClient, walletClient);
+    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}`);
@@ -20,17 +22,17 @@ export async function depositGovernanceTokens({ registryAddress, rpcUrls, chainI
 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 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, clients.publicClient, clients.walletClient);
+    const governance = new GovernanceContract(governanceAddress, client);
     const proposalId = await governance.proposeWithLock({
         payloadAddress,
-        withdrawAddress: clients.walletClient.account.address
+        withdrawAddress: client.account.address
     });
     if (json) {
         log(JSON.stringify({
-            proposalId
+            proposalId: Number(proposalId)
         }, null, 2));
     } else {
         log(`Proposed with lock`);
@@ -40,10 +42,10 @@ export async function proposeWithLock({ payloadAddress, registryAddress, rpcUrls
 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 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, clients.publicClient, clients.walletClient);
+    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.`);
@@ -64,10 +66,10 @@ export async function voteOnGovernanceProposal({ proposalId, voteAmount, inFavor
 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 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, clients.publicClient, clients.walletClient);
+    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.`);

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

@@ -1,4 +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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbWRzL2wxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsS0FBSyxPQUFPLEVBQVUsTUFBTSxXQUFXLENBQUM7QUF3QmpELHdCQUFnQixjQUFjLENBQUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBNmUvRSJ9

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

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

package/dest/cmds/l1/index.js

@@ -1,20 +1,20 @@
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Option } from 'commander';
-import { ETHEREUM_HOSTS, PRIVATE_KEY, l1ChainIdOption, makePxeOption, parseAztecAddress, parseBigint, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+import { ETHEREUM_HOSTS, MNEMONIC, PRIVATE_KEY, l1ChainIdOption, nodeOption, parseAztecAddress, 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) {
-    const { BB_BINARY_PATH, BB_WORKING_DIRECTORY } = process.env;
-    program.command('deploy-l1-contracts').description('Deploys all necessary Ethereum contracts for Aztec.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--validators <string>', 'Comma separated list of validators').option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').option('-i, --mnemonic-index <number>', 'The index of the mnemonic to use in deployment', (arg)=>parseInt(arg), 0).addOption(l1ChainIdOption).option('--salt <number>', 'The optional salt to use in deployment', (arg)=>parseInt(arg)).option('--json', 'Output the contract addresses in JSON format').option('--test-accounts', 'Populate genesis state with initial fee juice for test accounts').option('--accelerated-test-deployments', 'Fire and forget deployment transactions, use in testing only', false).action(async (options)=>{
-        const { deployL1Contracts } = await import('./deploy_l1_contracts.js');
+    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 deployL1Contracts(options.l1RpcUrls, options.l1ChainId, options.privateKey, options.mnemonic, options.mnemonicIndex, options.salt, options.testAccounts, options.acceleratedTestDeployments, options.json, initialValidators, log, debugLogger);
+        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 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)=>{
+    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.salt, options.testAccounts, options.json, initialValidators, log, debugLogger);
+        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('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');
@@ -94,16 +94,23 @@ export function injectCommands(program, log, debugLogger) {
         const account = generateL1Account();
         log(JSON.stringify(account, null, 2));
     });
-    program.command('add-l1-validator').description('Adds a validator to the L1 rollup contract.').addOption(l1RpcUrlsOption).option('-pk, --private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').addOption(l1ChainIdOption).option('--validator <address>', 'ethereum address of the validator', parseEthereumAddress).option('--rollup <address>', 'ethereum address of the rollup contract', parseEthereumAddress).option('--withdrawer <address>', 'ethereum address of the withdrawer', parseEthereumAddress).action(async (options)=>{
-        const { addL1Validator } = await import('./update_l1_validators.js');
-        await addL1Validator({
+    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,
-            validatorAddress: options.validator,
-            rollupAddress: options.rollup,
+            attesterAddress: options.attester,
+            blsSecretKey: options.blsSecretKey,
             withdrawerAddress: options.withdrawer,
+            rollupAddress,
+            moveWithLatestRollup: options.moveWithLatestRollup,
             log,
             debugLogger
         });
@@ -132,6 +139,17 @@ export function injectCommands(program, log, debugLogger) {
             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({
@@ -156,17 +174,9 @@ export function injectCommands(program, log, debugLogger) {
             debugLogger
         });
     });
-    program.command('deploy-l1-verifier').description('Deploys the rollup verifier contract').addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).addOption(makePxeOption(false).conflicts('rollup-address')).addOption(new Option('--rollup-address <string>', 'The address of the rollup contract').env('ROLLUP_CONTRACT_ADDRESS').argParser(parseEthereumAddress).conflicts('rpc-url')).option('--l1-private-key <string>', 'The L1 private key to use for deployment', PRIVATE_KEY).option('-m, --mnemonic <string>', 'The mnemonic to use in deployment', 'test test test test test test test test test test test junk').requiredOption('--verifier <verifier>', 'Either mock or real', 'real').option('--bb <path>', 'Path to bb binary', BB_BINARY_PATH).option('--bb-working-dir <path>', 'Path to bb working directory', BB_WORKING_DIRECTORY).action(async (options)=>{
-        const { deployMockVerifier, deployUltraHonkVerifier } = await import('./deploy_l1_verifier.js');
-        if (options.verifier === 'mock') {
-            await deployMockVerifier(options.rollupAddress?.toString(), options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, log, debugLogger);
-        } else {
-            await deployUltraHonkVerifier(options.rollupAddress?.toString(), options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.rpcUrl, options.bb, options.bbWorkingDir, log, debugLogger);
-        }
-    });
-    program.command('bridge-erc20').description('Bridges ERC20 tokens to L2.').argument('<amount>', 'The amount of Fee Juice to mint and bridge.', parseBigint).argument('<recipient>', 'Aztec address of the recipient.', parseAztecAddress).addOption(l1RpcUrlsOption).option('-m, --mnemonic <string>', 'The mnemonic to use for deriving the Ethereum address that will mint and bridge', 'test test test test test test test test test test test junk').option('--mint', 'Mint the tokens on L1', false).option('--private', 'If the bridge should use the private flow', false).addOption(l1ChainIdOption).requiredOption('-t, --token <string>', 'The address of the token to bridge', parseEthereumAddress).requiredOption('-p, --portal <string>', 'The address of the portal contract', parseEthereumAddress).option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--json', 'Output the claim in JSON format').action(async (amount, recipient, options)=>{
+    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('-f, --faucet <string>', 'The address of the faucet contract (only used if minting)', parseEthereumAddress).option('--l1-private-key <string>', 'The private key to use for deployment', PRIVATE_KEY).option('--json', 'Output the claim in JSON format').action(async (amount, recipient, options)=>{
         const { bridgeERC20 } = await import('./bridge_erc20.js');
-        await bridgeERC20(amount, recipient, options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.token, options.portal, options.private, options.mint, options.json, log, debugLogger);
+        await bridgeERC20(amount, recipient, options.l1RpcUrls, options.l1ChainId, options.l1PrivateKey, options.mnemonic, options.token, options.faucet, 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');
@@ -178,31 +188,13 @@ export function injectCommands(program, log, debugLogger) {
     });
     program.command('set-proven-through', {
         hidden: true
-    }).description('Instructs the L1 rollup contract to assume all blocks until the given number are automatically proven.').argument('[blockNumber]', 'The target block number, defaults to the latest pending block number.', parseBigint).addOption(l1RpcUrlsOption).addOption(pxeOption).action(async (blockNumber, options)=>{
+    }).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(nodeOption).action(async (blockNumber, options)=>{
         const { assumeProvenThrough } = await import('./assume_proven_through.js');
-        await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.rpcUrl, log);
+        await assumeProvenThrough(blockNumber, options.l1RpcUrls, options.nodeUrl, log);
     });
-    program.command('advance-epoch').description('Use L1 cheat codes to warp time until the next epoch.').addOption(l1RpcUrlsOption).addOption(pxeOption).action(async (options)=>{
+    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.rpcUrl, log);
-    });
-    program.command('prover-stats', {
-        hidden: true
-    }).addOption(l1RpcUrlsOption).addOption(l1ChainIdOption).option('--start-block <number>', 'The L1 block number to start from', parseBigint, 1n).option('--end-block <number>', 'The last L1 block number to query', parseBigint).option('--batch-size <number>', 'The number of blocks to query in each batch', parseBigint, 100n).option('--proving-timeout <number>', 'Cutoff for proving time to consider a block', parseBigint).option('--l1-rollup-address <string>', 'Address of the rollup contract (required if node URL is not set)').option('--node-url <string>', 'JSON RPC URL of an Aztec node to retrieve the rollup contract address (required if L1 rollup address is not set)').option('--raw-logs', 'Output raw logs instead of aggregated stats').action(async (options)=>{
-        const { proverStats } = await import('./prover_stats.js');
-        const { l1RpcUrls, chainId, l1RollupAddress, startBlock, endBlock, batchSize, nodeUrl, provingTimeout, rawLogs } = options;
-        await proverStats({
-            l1RpcUrls,
-            chainId,
-            l1RollupAddress,
-            startBlock,
-            endBlock,
-            batchSize,
-            nodeUrl,
-            provingTimeout,
-            rawLogs,
-            log
-        });
+        await advanceEpoch(options.l1RpcUrls, options.nodeUrl, log);
     });
     return program;
 }

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

@@ -11,4 +11,4 @@ export declare function proverStats(opts: {
     provingTimeout: bigint | undefined;
     rawLogs: boolean;
 }): Promise<void>;
-//# sourceMappingURL=prover_stats.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmVyX3N0YXRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9sMS9wcm92ZXJfc3RhdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsT0FBTyxFQUFFLEtBQUssS0FBSyxFQUE2QixNQUFNLHVCQUF1QixDQUFDO0FBUTlFLHdCQUFzQixXQUFXLENBQUMsSUFBSSxFQUFFO0lBQ3RDLFNBQVMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUNwQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLGVBQWUsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQ3BDLE9BQU8sRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzVCLEdBQUcsRUFBRSxLQUFLLENBQUM7SUFDWCxVQUFVLEVBQUUsTUFBTSxDQUFDO0lBQ25CLFFBQVEsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0lBQzdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsY0FBYyxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDbkMsT0FBTyxFQUFFLE9BQU8sQ0FBQztDQUNsQixpQkEwSUEifQ==

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

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

package/dest/cmds/l1/prover_stats.js

@@ -1,5 +1,5 @@
 import { retrieveL2ProofVerifiedEvents } from '@aztec/archiver';
-import { createEthereumChain } from '@aztec/ethereum';
+import { createEthereumChain } from '@aztec/ethereum/chain';
 import { compactArray, mapValues, unique } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
@@ -18,7 +18,9 @@ export async function proverStats(opts) {
     const chain = createEthereumChain(l1RpcUrls, chainId).chainInfo;
     const publicClient = createPublicClient({
         chain,
-        transport: fallback(l1RpcUrls.map((url)=>http(url)))
+        transport: fallback(l1RpcUrls.map((url)=>http(url, {
+                batch: false
+            })))
     });
     const lastBlockNum = endBlock ?? await publicClient.getBlockNumber();
     debugLog.verbose(`Querying events on rollup at ${rollup.toString()} from ${startBlock} up to ${lastBlockNum}`);
@@ -26,30 +28,30 @@ export async function proverStats(opts) {
     const events = await getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
     // If we only care for raw logs, output them
     if (rawLogs && !provingTimeout) {
-        log(`l1_block_number, l2_block_number, prover_id, tx_hash`);
+        log(`l1_block_number, checkpoint_number, prover_id, tx_hash`);
         for (const event of events){
-            const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-            log(`${l1BlockNumber}, ${l2BlockNumber}, ${proverId}, ${txHash}`);
+            const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+            log(`${l1BlockNumber}, ${checkpointNumber}, ${proverId}, ${txHash}`);
         }
         return;
     }
-    // If we don't have a proving timeout, we can just count the number of unique blocks per prover
+    // If we don't have a proving timeout, we can just count the number of unique checkpoints per prover
     if (!provingTimeout) {
         const stats = groupBy(events, 'proverId');
-        log(`prover_id, total_blocks_proven`);
+        log(`prover_id, total_checkpoints_proven`);
         for(const proverId in stats){
-            const uniqueBlocks = new Set(stats[proverId].map((e)=>e.l2BlockNumber));
-            log(`${proverId}, ${uniqueBlocks.size}`);
+            const uniqueCheckpoints = new Set(stats[proverId].map((e)=>e.checkpointNumber));
+            log(`${proverId}, ${uniqueCheckpoints.size}`);
         }
         return;
     }
-    // But if we do, fetch the events for each block submitted, so we can look up their timestamp
-    const blockEvents = await getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
-    debugLog.verbose(`First L2 block within range is ${blockEvents[0]?.args.blockNumber} at L1 block ${blockEvents[0]?.blockNumber}`);
+    // But if we do, fetch the events for each checkpoint submitted, so we can look up their timestamp
+    const checkpointEvents = await getCheckpointProposedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup);
+    debugLog.verbose(`First checkpoint within range is ${checkpointEvents[0]?.args.checkpointNumber} at L1 block ${checkpointEvents[0]?.blockNumber}`);
     // Get the timestamps for every block on every log, both for proof and block submissions
     const l1BlockNumbers = unique([
         ...events.map((e)=>e.l1BlockNumber),
-        ...blockEvents.map((e)=>e.blockNumber)
+        ...checkpointEvents.map((e)=>e.blockNumber)
     ]);
     const l1BlockTimestamps = {};
     for (const l1Batch of chunk(l1BlockNumbers, Number(batchSize))){
@@ -62,37 +64,37 @@ export async function proverStats(opts) {
             l1BlockTimestamps[block.number.toString()] = block.timestamp;
         }
     }
-    // Map from l2 block number to the l1 block in which it was submitted
-    const l2BlockSubmissions = {};
-    for (const blockEvent of blockEvents){
-        l2BlockSubmissions[blockEvent.args.blockNumber.toString()] = blockEvent.blockNumber;
+    // Map from checkpoint number to the l1 block in which it was submitted
+    const checkpointSubmissions = {};
+    for (const checkpointEvent of checkpointEvents){
+        checkpointSubmissions[checkpointEvent.args.checkpointNumber.toString()] = checkpointEvent.blockNumber;
     }
     // If we want raw logs, output them
     if (rawLogs) {
-        log(`l1_block_number, l2_block_number, l2_block_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
+        log(`l1_block_number, checkpoint_number, checkpoint_submission_timestamp, proof_timestamp, prover_id, tx_hash`);
         for (const event of events){
-            const { l1BlockNumber, l2BlockNumber, proverId, txHash } = event;
-            const uploadedBlockNumber = l2BlockSubmissions[l2BlockNumber.toString()];
+            const { l1BlockNumber, checkpointNumber, proverId, txHash } = event;
+            const uploadedBlockNumber = checkpointSubmissions[checkpointNumber.toString()];
             if (!uploadedBlockNumber) {
                 continue;
             }
             const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
             const provenTimestamp = l1BlockTimestamps[l1BlockNumber.toString()];
-            log(`${l1BlockNumber}, ${l2BlockNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
+            log(`${l1BlockNumber}, ${checkpointNumber}, ${uploadedTimestamp}, ${provenTimestamp}, ${proverId}, ${txHash}`);
         }
         return;
     }
     // Or calculate stats per prover
-    const stats = mapValues(groupBy(events, 'proverId'), (blocks, proverId)=>compactArray(blocks.map((e)=>{
+    const stats = mapValues(groupBy(events, 'proverId'), (checkpoints, proverId)=>compactArray(checkpoints.map((e)=>{
             const provenTimestamp = l1BlockTimestamps[e.l1BlockNumber.toString()];
-            const uploadedBlockNumber = l2BlockSubmissions[e.l2BlockNumber.toString()];
+            const uploadedBlockNumber = checkpointSubmissions[e.checkpointNumber.toString()];
             if (!uploadedBlockNumber) {
-                debugLog.verbose(`Skipping ${proverId}'s proof for L2 block ${e.l2BlockNumber} as it was before the start block`);
+                debugLog.verbose(`Skipping ${proverId}'s proof for checkpoint ${e.checkpointNumber} as it was before the start block`);
                 return undefined;
             }
             const uploadedTimestamp = l1BlockTimestamps[uploadedBlockNumber.toString()];
             const provingTime = provenTimestamp - uploadedTimestamp;
-            debugLog.debug(`prover=${e.proverId} blockNumber=${e.l2BlockNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`);
+            debugLog.debug(`prover=${e.proverId} checkpointNumber=${e.checkpointNumber} uploaded=${uploadedTimestamp} proven=${provenTimestamp} time=${provingTime}`);
             return {
                 provenTimestamp,
                 uploadedTimestamp,
@@ -104,8 +106,8 @@ export async function proverStats(opts) {
     for(const proverId in stats){
         const blocks = stats[proverId];
         const withinTimeout = blocks.filter((b)=>b.provingTime <= provingTimeout);
-        const uniqueBlocksWithinTimeout = new Set(withinTimeout.map((e)=>e.l2BlockNumber));
-        const uniqueBlocks = new Set(blocks.map((e)=>e.l2BlockNumber));
+        const uniqueBlocksWithinTimeout = new Set(withinTimeout.map((e)=>e.checkpointNumber));
+        const uniqueBlocks = new Set(blocks.map((e)=>e.checkpointNumber));
         const avgProvingTime = blocks.length === 0 ? 0 : Math.ceil(Number(blocks.reduce((acc, b)=>acc + b.provingTime, 0n)) / blocks.length);
         log(`${proverId}, ${uniqueBlocksWithinTimeout.size}, ${uniqueBlocks.size}, ${avgProvingTime}`);
     }
@@ -123,7 +125,7 @@ async function getL2ProofVerifiedEvents(startBlock, lastBlockNum, batchSize, deb
     }
     return events;
 }
-async function getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
+async function getCheckpointProposedEvents(startBlock, lastBlockNum, batchSize, debugLog, publicClient, rollup) {
     let blockNum = startBlock;
     const events = [];
     while(blockNum <= lastBlockNum){
@@ -132,13 +134,13 @@ async function getL2BlockEvents(startBlock, lastBlockNum, batchSize, debugLog, p
             address: getAddress(rollup.toString()),
             event: getAbiItem({
                 abi: RollupAbi,
-                name: 'L2BlockProposed'
+                name: 'CheckpointProposed'
             }),
             fromBlock: blockNum,
             toBlock: end
         });
         events.push(...newEvents);
-        debugLog.verbose(`Got ${newEvents.length} events querying l2 block submitted from block ${blockNum} to ${end}`);
+        debugLog.verbose(`Got ${newEvents.length} events querying checkpoints submitted from block ${blockNum} to ${end}`);
         blockNum += batchSize;
     }
     return events;

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

@@ -0,0 +1,6 @@
+import type { LogFn } from '@aztec/foundation/log';
+import type { RollupCommandArgs } from './update_l1_validators.js';
+export declare function triggerSeedSnapshot({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log }: RollupCommandArgs & {
+    log: LogFn;
+}): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJpZ2dlcl9zZWVkX3NuYXBzaG90LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY21kcy9sMS90cmlnZ2VyX3NlZWRfc25hcHNob3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFLbkQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVuRSx3QkFBc0IsbUJBQW1CLENBQUMsRUFDeEMsT0FBTyxFQUNQLE9BQU8sRUFDUCxVQUFVLEVBQ1YsUUFBUSxFQUNSLGFBQWEsRUFDYixHQUFHLEVBQ0osRUFBRSxpQkFBaUIsR0FBRztJQUFFLEdBQUcsRUFBRSxLQUFLLENBQUE7Q0FBRSxpQkFlcEMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigger_seed_snapshot.d.ts","sourceRoot":"","sources":["../../../src/cmds/l1/trigger_seed_snapshot.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAKnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,wBAAsB,mBAAmB,CAAC,EACxC,OAAO,EACP,OAAO,EACP,UAAU,EACV,QAAQ,EACR,aAAa,EACb,GAAG,EACJ,EAAE,iBAAiB,GAAG;IAAE,GAAG,EAAE,KAAK,CAAA;CAAE,iBAepC"}

package/dest/cmds/l1/trigger_seed_snapshot.js

@@ -0,0 +1,20 @@
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import { getContract } from 'viem';
+export async function triggerSeedSnapshot({ rpcUrls, chainId, privateKey, mnemonic, rollupAddress, log }) {
+    const chain = createEthereumChain(rpcUrls, chainId);
+    const client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+    const rollup = getContract({
+        address: rollupAddress.toString(),
+        abi: RollupAbi,
+        client
+    });
+    log('Triggering seed snapshot for next epoch');
+    const txHash = await rollup.write.checkpointRandao();
+    log(`Sent! | Seed snapshot setup for next epoch | tx hash: ${txHash}`);
+    const receipt = await client.waitForTransactionReceipt({
+        hash: txHash
+    });
+    log(`Done! | Seed snapshot setup for next epoch | tx hash: ${txHash} | status: ${receipt.status}`);
+}