@aztec/cli 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/cmds/aztec_node/get_l1_to_l2_message_witness.ts

@@ -0,0 +1,27 @@
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { LogFn } from '@aztec/foundation/log';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+
+export async function getL1ToL2MessageWitness(
+  nodeUrl: string,
+  contractAddress: AztecAddress,
+  messageHash: Fr,
+  secret: Fr,
+  log: LogFn,
+) {
+  const node = createAztecNodeClient(nodeUrl);
+  const messageWitness = await getNonNullifiedL1ToL2MessageWitness(node, contractAddress, messageHash, secret);
+
+  log(
+    messageWitness === undefined
+      ? `
+    L1 to L2 Message not found.
+    `
+      : `
+    L1 to L2 message index: ${messageWitness[0]}
+    L1 to L2 message sibling path: ${messageWitness[1]}
+    `,
+  );
+}

package/src/cmds/{pxe → aztec_node}/get_logs.ts

@@ -1,20 +1,22 @@
-import type { AztecAddress, LogFilter, LogId, TxHash } from '@aztec/aztec.js';
-import { createCompatibleClient } from '@aztec/aztec.js';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { LogFilter, LogId } from '@aztec/aztec.js/log';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { TxHash } from '@aztec/aztec.js/tx';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { LogFn } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 
 export async function getLogs(
   txHash: TxHash,
-  fromBlock: number,
-  toBlock: number,
+  fromBlock: BlockNumber,
+  toBlock: BlockNumber,
   afterLog: LogId,
   contractAddress: AztecAddress,
-  rpcUrl: string,
+  nodeUrl: string,
   follow: boolean,
-  debugLogger: Logger,
   log: LogFn,
 ) {
-  const pxe = await createCompatibleClient(rpcUrl, debugLogger);
+  const node = createAztecNodeClient(nodeUrl);
 
   if (follow) {
     if (txHash) {
@@ -28,7 +30,7 @@ export async function getLogs(
   const filter: LogFilter = { txHash, fromBlock, toBlock, afterLog, contractAddress };
 
   const fetchLogs = async () => {
-    const response = await pxe.getPublicLogs(filter);
+    const response = await node.getPublicLogs(filter);
     const logs = response.logs;
 
     if (!logs.length) {

package/src/cmds/{pxe → aztec_node}/get_node_info.ts

@@ -1,26 +1,15 @@
-import { type AztecNode, type PXE, createAztecNodeClient, createCompatibleClient } from '@aztec/aztec.js';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function getNodeInfo(nodeUrl: string, json: boolean, log: LogFn, logJson: (output: any) => void) {
+  const client = createAztecNodeClient(nodeUrl);
 
-export async function getNodeInfo(
-  rpcUrl: string,
-  pxeRequest: boolean,
-  debugLogger: Logger,
-  json: boolean,
-  log: LogFn,
-  logJson: (output: any) => void,
-) {
-  let client: AztecNode | PXE;
-  if (pxeRequest) {
-    client = await createCompatibleClient(rpcUrl, debugLogger);
-  } else {
-    client = createAztecNodeClient(rpcUrl);
-  }
   const info = await client.getNodeInfo();
   if (json) {
     logJson({
       nodeVersion: info.nodeVersion,
       l1ChainId: info.l1ChainId,
-      protocolVersion: info.protocolVersion,
+      rollupVersion: info.rollupVersion,
       enr: info.enr,
       l1ContractAddresses: {
         rollup: info.l1ContractAddresses.rollupAddress.toString(),
@@ -35,18 +24,20 @@ export async function getNodeInfo(
         governanceProposer: info.l1ContractAddresses.governanceProposerAddress.toString(),
         governance: info.l1ContractAddresses.governanceAddress.toString(),
         slashFactory: info.l1ContractAddresses.slashFactoryAddress?.toString(),
+        feeAssetHandler: info.l1ContractAddresses.feeAssetHandlerAddress?.toString(),
+        stakingAssetHandler: info.l1ContractAddresses.stakingAssetHandlerAddress?.toString(),
       },
       protocolContractAddresses: {
-        classRegisterer: info.protocolContractAddresses.classRegisterer.toString(),
+        classRegistry: info.protocolContractAddresses.classRegistry.toString(),
         feeJuice: info.protocolContractAddresses.feeJuice.toString(),
-        instanceDeployer: info.protocolContractAddresses.instanceDeployer.toString(),
+        instanceRegistry: info.protocolContractAddresses.instanceRegistry.toString(),
         multiCallEntrypoint: info.protocolContractAddresses.multiCallEntrypoint.toString(),
       },
     });
   } else {
     log(`Node Version: ${info.nodeVersion}`);
     log(`Chain Id: ${info.l1ChainId}`);
-    log(`Protocol Version: ${info.protocolVersion}`);
+    log(`Rollup Version: ${info.rollupVersion}`);
     log(`Node ENR: ${info.enr}`);
     log(`L1 Contract Addresses:`);
     log(` Rollup Address: ${info.l1ContractAddresses.rollupAddress.toString()}`);
@@ -61,11 +52,12 @@ export async function getNodeInfo(
     log(` GovernanceProposer Address: ${info.l1ContractAddresses.governanceProposerAddress.toString()}`);
     log(` Governance Address: ${info.l1ContractAddresses.governanceAddress.toString()}`);
     log(` SlashFactory Address: ${info.l1ContractAddresses.slashFactoryAddress?.toString()}`);
-
+    log(` FeeAssetHandler Address: ${info.l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
+    log(` StakingAssetHandler Address: ${info.l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
     log(`L2 Contract Addresses:`);
-    log(` Class Registerer: ${info.protocolContractAddresses.classRegisterer.toString()}`);
+    log(` Class Registry: ${info.protocolContractAddresses.classRegistry.toString()}`);
     log(` Fee Juice: ${info.protocolContractAddresses.feeJuice.toString()}`);
-    log(` Instance Deployer: ${info.protocolContractAddresses.instanceDeployer.toString()}`);
+    log(` Instance Deployer: ${info.protocolContractAddresses.instanceRegistry.toString()}`);
     log(` MultiCall: ${info.protocolContractAddresses.multiCallEntrypoint.toString()}`);
   }
 }

package/src/cmds/aztec_node/index.ts

@@ -0,0 +1,87 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import {
+  logJson,
+  nodeOption,
+  parseAztecAddress,
+  parseField,
+  parseOptionalAztecAddress,
+  parseOptionalInteger,
+  parseOptionalLogId,
+  parseOptionalTxHash,
+} from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('get-block')
+    .description('Gets info for a given block or latest.')
+    .argument('[blockNumber]', 'Block height', parseOptionalInteger)
+    .addOption(nodeOption)
+    .action(async (blockNumber, options) => {
+      const { getBlock } = await import('./get_block.js');
+      await getBlock(options.nodeUrl, blockNumber, log);
+    });
+
+  program
+    .command('get-current-min-fee')
+    .description('Gets the current base fee.')
+    .addOption(nodeOption)
+    .action(async options => {
+      const { getCurrentMinFee } = await import('./get_current_min_fee.js');
+      await getCurrentMinFee(options.rpcUrl, debugLogger, log);
+    });
+
+  program
+    .command('get-l1-to-l2-message-witness')
+    .description('Gets a L1 to L2 message witness.')
+    .requiredOption('-ca, --contract-address <address>', 'Aztec address of the contract.', parseAztecAddress)
+    .requiredOption('--message-hash <messageHash>', 'The L1 to L2 message hash.', parseField)
+    .requiredOption('--secret <secret>', 'The secret used to claim the L1 to L2 message', parseField)
+    .addOption(nodeOption)
+    .action(async ({ contractAddress, messageHash, secret, nodeUrl }) => {
+      const { getL1ToL2MessageWitness } = await import('./get_l1_to_l2_message_witness.js');
+      await getL1ToL2MessageWitness(nodeUrl, contractAddress, messageHash, secret, log);
+    });
+
+  program
+    .command('get-logs')
+    .description('Gets all the public logs from an intersection of all the filter params.')
+    .option('-tx, --tx-hash <txHash>', 'A transaction hash to get the receipt for.', parseOptionalTxHash)
+    .option(
+      '-fb, --from-block <blockNum>',
+      'Initial block number for getting logs (defaults to 1).',
+      parseOptionalInteger,
+    )
+    .option('-tb, --to-block <blockNum>', 'Up to which block to fetch logs (defaults to latest).', parseOptionalInteger)
+    .option('-al --after-log <logId>', 'ID of a log after which to fetch the logs.', parseOptionalLogId)
+    .option('-ca, --contract-address <address>', 'Contract address to filter logs by.', parseOptionalAztecAddress)
+    .addOption(nodeOption)
+    .option('--follow', 'If set, will keep polling for new logs until interrupted.')
+    .action(async ({ txHash, fromBlock, toBlock, afterLog, contractAddress, aztecNodeRpcUrl: nodeUrl, follow }) => {
+      const { getLogs } = await import('./get_logs.js');
+      await getLogs(txHash, fromBlock, toBlock, afterLog, contractAddress, nodeUrl, follow, log);
+    });
+
+  program
+    .command('block-number')
+    .description('Gets the current Aztec L2 block number.')
+    .addOption(nodeOption)
+    .action(async (options: any) => {
+      const { blockNumber } = await import('./block_number.js');
+      await blockNumber(options.nodeUrl, log);
+    });
+
+  program
+    .command('get-node-info')
+    .description('Gets the information of an Aztec node from a PXE or directly from an Aztec node.')
+    .option('--json', 'Emit output as json')
+    .addOption(nodeOption)
+    .action(async options => {
+      const { getNodeInfo } = await import('./get_node_info.js');
+      await getNodeInfo(options.nodeUrl, options.json, log, logJson(log));
+    });
+
+  return program;
+}

package/src/cmds/contracts/inspect_contract.ts

@@ -1,10 +1,11 @@
-import { sha256 } from '@aztec/foundation/crypto';
+import { sha256 } from '@aztec/foundation/crypto/sha256';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 import {
   type FunctionArtifact,
   FunctionSelector,
   decodeFunctionSignature,
   decodeFunctionSignatureWithParameterNames,
+  retainBytecode,
 } from '@aztec/stdlib/abi';
 import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
 
@@ -12,7 +13,9 @@ import { getContractArtifact } from '../../utils/aztec.js';
 
 export async function inspectContract(contractArtifactFile: string, debugLogger: Logger, log: LogFn) {
   const contractArtifact = await getContractArtifact(contractArtifactFile, log);
-  const contractFns = contractArtifact.functions;
+  const contractFns = contractArtifact.functions.concat(
+    contractArtifact.nonDispatchPublicFunctions.map(f => f as FunctionArtifact),
+  );
   if (contractFns.length === 0) {
     log(`No functions found for contract ${contractArtifact.name}`);
   }
@@ -26,16 +29,9 @@ export async function inspectContract(contractArtifactFile: string, debugLogger:
   log(`\tpublic bytecode commitment: ${contractClass.publicBytecodeCommitment.toString()}`);
   log(`\tpublic bytecode length: ${contractClass.packedBytecode.length} bytes (${bytecodeLengthInFields} fields)`);
 
-  const externalFunctions = contractFns.filter(f => !f.isInternal);
-  if (externalFunctions.length > 0) {
-    log(`\nExternal functions:`);
-    await Promise.all(externalFunctions.map(f => logFunction(f, log)));
-  }
-
-  const internalFunctions = contractFns.filter(f => f.isInternal);
-  if (internalFunctions.length > 0) {
-    log(`\nInternal functions:`);
-    await Promise.all(internalFunctions.map(f => logFunction(f, log)));
+  if (contractFns.length > 0) {
+    log(`\nExternal contract functions:`);
+    await Promise.all(contractFns.map(f => logFunction(f, log)));
   }
 }
 
@@ -43,9 +39,16 @@ async function logFunction(fn: FunctionArtifact, log: LogFn) {
   const signatureWithParameterNames = decodeFunctionSignatureWithParameterNames(fn.name, fn.parameters);
   const signature = decodeFunctionSignature(fn.name, fn.parameters);
   const selector = await FunctionSelector.fromSignature(signature);
-  const bytecodeSize = fn.bytecode.length;
-  const bytecodeHash = sha256(fn.bytecode).toString('hex');
-  log(
-    `${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}\n\tbytecode: ${bytecodeSize} bytes (sha256 ${bytecodeHash})`,
-  );
+
+  if (retainBytecode(fn)) {
+    const bytecodeSize = fn.bytecode.length;
+    const bytecodeHash = sha256(fn.bytecode).toString('hex');
+    log(
+      `${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}\n\tbytecode: ${bytecodeSize} bytes (sha256 ${bytecodeHash})`,
+    );
+  } else {
+    log(
+      `${fn.functionType} ${signatureWithParameterNames} \n\tfunction signature: ${signature}\n\tselector: ${selector}`,
+    );
+  }
 }

package/src/cmds/infrastructure/index.ts

@@ -1,20 +1,19 @@
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 
 import type { Command } from 'commander';
 
-import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+import { ETHEREUM_HOSTS, l1ChainIdOption, nodeOption, parseOptionalInteger } from '../../utils/commands.js';
 
-export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+export function injectCommands(program: Command, log: LogFn) {
   program
     .command('setup-protocol-contracts')
     .description('Bootstrap the blockchain by initializing all the protocol contracts')
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .option('--testAccounts', 'Deploy funded test accounts.')
     .option('--json', 'Output the contract addresses in JSON format')
-    .option('--skipProofWait', "Don't wait for proofs to land.")
     .action(async options => {
       const { setupL2Contracts } = await import('./setup_l2_contract.js');
-      await setupL2Contracts(options.rpcUrl, options.testAccounts, options.json, options.skipProofWait, log);
+      await setupL2Contracts(options.nodeUrl, options.testAccounts, options.json, log);
     });
 
   program
@@ -34,7 +33,7 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
       'test test test test test test test test test test test junk',
     )
     .option('--block-number <number>', 'Block number to query next sequencer for', parseOptionalInteger)
-    .addOption(pxeOption)
+    .addOption(nodeOption)
     .addOption(l1ChainIdOption)
     .action(async (command, who, options) => {
       const { sequencers } = await import('./sequencers.js');
@@ -42,12 +41,10 @@ export function injectCommands(program: Command, log: LogFn, debugLogger: Logger
         command: command,
         who,
         mnemonic: options.mnemonic,
-        rpcUrl: options.rpcUrl,
-        l1RpcUrls: options.l1RpcUrls.split(','),
+        nodeUrl: options.nodeUrl,
+        l1RpcUrls: options.l1RpcUrls,
         chainId: options.l1ChainId,
-        blockNumber: options.blockNumber,
         log,
-        debugLogger,
       });
     });
 

package/src/cmds/infrastructure/sequencers.ts

@@ -1,45 +1,43 @@
-import { createCompatibleClient } from '@aztec/aztec.js';
-import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import type { LogFn, Logger } from '@aztec/foundation/log';
+import { Fr } from '@aztec/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec/ethereum/contracts';
+import type { LogFn } from '@aztec/foundation/log';
 import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 
 import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
 import { mnemonicToAccount } from 'viem/accounts';
 
 export async function sequencers(opts: {
-  command: 'list' | 'add' | 'remove' | 'who-next';
+  command: 'list' | 'add' | 'remove' | 'who-next' | 'flush';
   who?: string;
   mnemonic?: string;
-  rpcUrl: string;
+  bn254SecretKey?: bigint;
+  nodeUrl: string;
   l1RpcUrls: string[];
   chainId: number;
-  blockNumber?: number;
   log: LogFn;
-  debugLogger: Logger;
 }) {
-  const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrls, chainId, log, debugLogger } = opts;
-  const client = await createCompatibleClient(rpcUrl, debugLogger);
+  const { command, who: maybeWho, mnemonic, bn254SecretKey, nodeUrl, l1RpcUrls, chainId, log } = opts;
+  const client = createAztecNodeClient(nodeUrl);
   const { l1ContractAddresses } = await client.getNodeInfo();
 
   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 }))),
   });
 
   const walletClient = mnemonic
     ? createWalletClient({
         account: mnemonicToAccount(mnemonic),
         chain: chain.chainInfo,
-        transport: fallback(l1RpcUrls.map(url => http(url))),
+        transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
       })
     : undefined;
 
-  const rollup = getContract({
-    address: l1ContractAddresses.rollupAddress.toString(),
-    abi: RollupAbi,
-    client: publicClient,
-  });
+  const rollup = new RollupContract(publicClient, l1ContractAddresses.rollupAddress);
 
   const writeableRollup = walletClient
     ? getContract({
@@ -52,7 +50,7 @@ export async function sequencers(opts: {
   const who = (maybeWho as `0x{string}`) ?? walletClient?.account.address.toString();
 
   if (command === 'list') {
-    const sequencers = await rollup.read.getAttesters();
+    const sequencers = await rollup.getAttesters();
     if (sequencers.length === 0) {
       log(`No sequencers registered on rollup`);
     } else {
@@ -68,24 +66,45 @@ export async function sequencers(opts: {
 
     log(`Adding ${who} as sequencer`);
 
+    const stakingAssetAddress = await rollup.getStakingAsset();
     const stakingAsset = getContract({
-      address: await rollup.read.getStakingAsset(),
+      address: stakingAssetAddress.toString(),
       abi: TestERC20Abi,
       client: walletClient,
     });
 
     const config = getL1ContractsConfigEnvVars();
 
+    const bn254SecretKeyFieldElement = bn254SecretKey ? new Fr(bn254SecretKey) : Fr.random();
+    const gseAddress = await rollup.getGSE();
+    const gseContract = new GSEContract(publicClient, gseAddress);
+    const registrationTuple = await gseContract.makeRegistrationTuple(bn254SecretKeyFieldElement.toBigInt());
+
     await Promise.all(
       [
-        await stakingAsset.write.mint([walletClient.account.address, config.minimumStake], {} as any),
-        await stakingAsset.write.approve([rollup.address, config.minimumStake], {} as any),
+        await stakingAsset.write.mint([walletClient.account.address, config.activationThreshold], {} as any),
+        await stakingAsset.write.approve([rollup.address, config.activationThreshold], {} as any),
       ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
     );
 
-    const hash = await writeableRollup.write.deposit([who, who, who, config.minimumStake]);
+    const hash = await writeableRollup.write.deposit([
+      who,
+      who,
+      registrationTuple.publicKeyInG1,
+      registrationTuple.publicKeyInG2,
+      registrationTuple.proofOfPossession,
+      true,
+    ]);
     await publicClient.waitForTransactionReceipt({ hash });
     log(`Added in tx ${hash}`);
+  } else if (command === 'flush') {
+    if (!writeableRollup) {
+      throw new Error(`Missing sequencer address`);
+    }
+    log(`Flushing staking entry queue`);
+    const hash = await writeableRollup.write.flushEntryQueue();
+    await publicClient.waitForTransactionReceipt({ hash });
+    log(`Flushed staking entry queue in tx ${hash}`);
   } else if (command === 'remove') {
     if (!who || !writeableRollup) {
       throw new Error(`Missing sequencer address`);
@@ -95,7 +114,7 @@ export async function sequencers(opts: {
     await publicClient.waitForTransactionReceipt({ hash });
     log(`Removed in tx ${hash}`);
   } else if (command === 'who-next') {
-    const next = await rollup.read.getCurrentProposer();
+    const next = await rollup.getCurrentProposer();
     log(`Sequencer expected to build is ${next}`);
   } else {
     throw new Error(`Unknown command ${command}`);

package/src/cmds/infrastructure/setup_l2_contract.ts

@@ -1,45 +1,33 @@
-import { type InitialAccountData, deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
-import { type AztecAddress, SignerlessWallet, type WaitOpts, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { WaitOpts } from '@aztec/aztec.js/contracts';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { AccountManager } from '@aztec/aztec.js/wallet';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { LogFn } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { TestWallet, deployFundedSchnorrAccounts } from '@aztec/test-wallet/server';
 
-import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
-
-export async function setupL2Contracts(
-  rpcUrl: string,
-  testAccounts: boolean,
-  json: boolean,
-  skipProofWait: boolean,
-  log: LogFn,
-) {
+export async function setupL2Contracts(nodeUrl: string, testAccounts: boolean, json: boolean, log: LogFn) {
   const waitOpts: WaitOpts = {
     timeout: 180,
     interval: 1,
-    proven: !skipProofWait,
-    provenTimeout: 600,
   };
   log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
   log('setupL2Contracts: Creating PXE client...');
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([1, 1, 1, 1, 1], false));
-  const wallet = new SignerlessWallet(pxe);
-
-  log('setupL2Contracts: Getting fee juice portal address...');
-  // Deploy Fee Juice
-  const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
-  log('setupL2Contracts: Setting up fee juice portal...');
-  await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+  const node = createAztecNodeClient(nodeUrl);
+  const wallet = await TestWallet.create(node);
 
-  let deployedAccounts: InitialAccountData[] = [];
+  let deployedAccountManagers: AccountManager[] = [];
   if (testAccounts) {
     log('setupL2Contracts: Deploying test accounts...');
-    deployedAccounts = await getInitialTestAccounts();
-    await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
+    const initialAccountsData = await getInitialTestAccountsData();
+    deployedAccountManagers = await deployFundedSchnorrAccounts(wallet, initialAccountsData, waitOpts);
   }
 
   if (json) {
     const toPrint: Record<string, AztecAddress> = { ...ProtocolContractAddress };
-    deployedAccounts.forEach((a, i) => {
+    deployedAccountManagers.forEach((a, i) => {
       toPrint[`testAccount${i}`] = a.address;
     });
     log(JSON.stringify(toPrint, null, 2));

package/src/cmds/l1/advance_epoch.ts

@@ -1,11 +1,13 @@
-import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { RollupCheatCodes } from '@aztec/ethereum/test';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
-export async function advanceEpoch(l1RpcUrls: string[], rpcUrl: string, log: LogFn) {
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
-  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+export async function advanceEpoch(l1RpcUrls: string[], nodeUrl: string, log: LogFn) {
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
 
-  const cheat = CheatCodes.createRollup(l1RpcUrls, { rollupAddress });
+  const cheat = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
   await cheat.advanceToNextEpoch();
   log(`Warped time to advance to next epoch`);

package/src/cmds/l1/assume_proven_through.ts

@@ -1,19 +1,20 @@
-import { EthCheatCodes, RollupCheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createAztecNodeClient } from '@aztec/aztec.js/node';
+import { RollupCheatCodes } from '@aztec/ethereum/test';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { LogFn } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
 
 export async function assumeProvenThrough(
-  blockNumberOrLatest: number | undefined,
+  checkpointOrLatest: CheckpointNumber | undefined,
   l1RpcUrls: string[],
-  rpcUrl: string,
+  nodeUrl: string,
   log: LogFn,
 ) {
-  const pxe = createPXEClient(rpcUrl, {}, makeFetch([], true));
-  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
-  const blockNumber = blockNumberOrLatest ?? (await pxe.getBlockNumber());
+  const aztecNode = createAztecNodeClient(nodeUrl);
+  const rollupAddress = await aztecNode.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
 
-  const ethCheatCode = new EthCheatCodes(l1RpcUrls);
-  const rollupCheatCodes = new RollupCheatCodes(ethCheatCode, { rollupAddress });
+  const rollupCheatCodes = RollupCheatCodes.create(l1RpcUrls, { rollupAddress }, new DateProvider());
 
-  await rollupCheatCodes.markAsProven(blockNumber);
-  log(`Assumed proven through block ${blockNumber}`);
+  await rollupCheatCodes.markAsProven(checkpointOrLatest);
+  log(`Assumed proven through checkpoint ${checkpointOrLatest ?? 'latest'}`);
 }

package/src/cmds/l1/bridge_erc20.ts

@@ -1,5 +1,8 @@
-import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
-import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import type { AztecAddress, EthAddress } from '@aztec/aztec.js/addresses';
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js/ethereum';
+import type { Fr } from '@aztec/aztec.js/fields';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
 import type { LogFn, Logger } from '@aztec/foundation/log';
 
 import { prettyPrintJSON } from '../../utils/commands.js';
@@ -12,6 +15,7 @@ export async function bridgeERC20(
   privateKey: string | undefined,
   mnemonic: string,
   tokenAddress: EthAddress,
+  handlerAddress: EthAddress | undefined,
   portalAddress: EthAddress,
   privateTransfer: boolean,
   mint: boolean,
@@ -21,10 +25,10 @@ export async function bridgeERC20(
 ) {
   // Prepare L1 client
   const chain = createEthereumChain(l1RpcUrls, chainId);
-  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
+  const l1Client = createExtendedL1Client(chain.rpcUrls, privateKey ?? mnemonic, chain.chainInfo);
 
   // Setup portal manager
-  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, handlerAddress, l1Client, debugLogger);
   let claimSecret: Fr;
   let messageHash: `0x${string}`;
   if (privateTransfer) {

package/src/cmds/l1/compute_genesis_values.ts

@@ -0,0 +1,29 @@
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import type { LogFn } from '@aztec/foundation/log';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+
+/** Computes and prints genesis values needed for L1 contract deployment. */
+export async function computeGenesisValuesCmd(testAccounts: boolean, sponsoredFPC: boolean, log: LogFn) {
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+  const sponsoredFPCAddresses = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+  const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddresses);
+  const { genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts);
+
+  const { getVKTreeRoot } = await import('@aztec/noir-protocol-circuits-types/vk-tree');
+  const vkTreeRoot = getVKTreeRoot();
+
+  log(
+    JSON.stringify(
+      {
+        vkTreeRoot: vkTreeRoot.toString(),
+        protocolContractsHash: protocolContractsHash.toString(),
+        genesisArchiveRoot: genesisArchiveRoot.toString(),
+      },
+      null,
+      2,
+    ),
+  );
+}