@aztec/cli 0.17.0 → 0.77.0-testnet-ignition.17

package/src/cmds/devnet/bootstrap_network.ts

@@ -0,0 +1,318 @@
+import { getDeployedTestAccountsWallets } from '@aztec/accounts/testing';
+import {
+  AztecAddress,
+  BatchCall,
+  EthAddress,
+  Fr,
+  L1FeeJuicePortalManager,
+  type PXE,
+  type WaitOpts,
+  type Wallet,
+  createCompatibleClient,
+  retryUntil,
+} from '@aztec/aztec.js';
+import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
+import {
+  type ContractArtifacts,
+  type L1Clients,
+  createEthereumChain,
+  createL1Clients,
+  deployL1Contract,
+} from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { getContract } from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+
+type ContractDeploymentInfo = {
+  address: AztecAddress;
+  initHash: Fr;
+  salt: Fr;
+};
+
+const waitOpts: WaitOpts = {
+  timeout: 120,
+  provenTimeout: 4800,
+  interval: 1,
+};
+
+export async function bootstrapNetwork(
+  pxeUrl: string,
+  l1Urls: string[],
+  l1ChainId: string,
+  l1PrivateKey: `0x${string}` | undefined,
+  l1Mnemonic: string,
+  addressIndex: number,
+  json: boolean,
+  log: LogFn,
+  debugLog: Logger,
+) {
+  const pxe = await createCompatibleClient(pxeUrl, debugLog);
+
+  const [wallet] = await getDeployedTestAccountsWallets(pxe);
+
+  const l1Clients = createL1Clients(
+    l1Urls,
+    l1PrivateKey
+      ? privateKeyToAccount(l1PrivateKey)
+      : // We need to use a different account that the main "deployer" account because the "deployer" account creates transactions that send blobs.
+        // Note that this account needs to be funded on L1 !
+        mnemonicToAccount(l1Mnemonic, { addressIndex }),
+    createEthereumChain(l1Urls, +l1ChainId).chainInfo,
+  );
+
+  const { erc20Address, portalAddress } = await deployERC20(l1Clients);
+
+  const { token, bridge } = await deployToken(wallet, portalAddress);
+
+  await initPortal(pxe, l1Clients, erc20Address, portalAddress, bridge.address);
+
+  const fpcAdmin = wallet.getAddress();
+  const fpc = await deployFPC(wallet, token.address, fpcAdmin);
+
+  const counter = await deployCounter(wallet);
+
+  await fundFPC(counter.address, wallet, l1Clients, fpc.address, debugLog);
+
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          devCoinL1: erc20Address.toString(),
+          devCoinPortalL1: portalAddress.toString(),
+          devCoin: {
+            address: token.address.toString(),
+            initHash: token.initHash.toString(),
+            salt: token.salt.toString(),
+          },
+          devCoinBridge: {
+            address: bridge.address.toString(),
+            initHash: bridge.initHash.toString(),
+            salt: bridge.salt.toString(),
+          },
+          devCoinFpc: {
+            address: fpc.address.toString(),
+            initHash: fpc.initHash.toString(),
+            salt: fpc.salt.toString(),
+          },
+          counter: {
+            address: counter.address.toString(),
+            initHash: counter.initHash.toString(),
+            salt: counter.salt.toString(),
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`DevCoin L1: ${erc20Address}`);
+    log(`DevCoin L1 Portal: ${portalAddress}`);
+    log(`DevCoin L2: ${token.address}`);
+    log(`DevCoin L2 init hash: ${token.initHash}`);
+    log(`DevCoin L2 salt: ${token.salt}`);
+    log(`DevCoin L2 Bridge: ${bridge.address}`);
+    log(`DevCoin L2 Bridge init hash: ${bridge.initHash}`);
+    log(`DevCoin L2 Bridge salt: ${bridge.salt}`);
+    log(`DevCoin FPC: ${fpc.address}`);
+    log(`DevCoin FPC init hash: ${fpc.initHash}`);
+    log(`DevCoin FPC salt: ${fpc.salt}`);
+    log(`Counter: ${counter.address}`);
+    log(`Counter init hash: ${counter.initHash}`);
+    log(`Counter salt: ${counter.salt}`);
+  }
+}
+
+/**
+ * Step 1. Deploy the L1 contracts, but don't initialize
+ */
+async function deployERC20({ walletClient, publicClient }: L1Clients) {
+  const { TestERC20Abi, TestERC20Bytecode, TokenPortalAbi, TokenPortalBytecode } = await import('@aztec/l1-artifacts');
+
+  const erc20: ContractArtifacts = {
+    contractAbi: TestERC20Abi,
+    contractBytecode: TestERC20Bytecode,
+  };
+  const portal: ContractArtifacts = {
+    contractAbi: TokenPortalAbi,
+    contractBytecode: TokenPortalBytecode,
+  };
+
+  const { address: erc20Address } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    erc20.contractAbi,
+    erc20.contractBytecode,
+    ['DevCoin', 'DEV', walletClient.account.address],
+  );
+  const { address: portalAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    portal.contractAbi,
+    portal.contractBytecode,
+  );
+
+  return {
+    erc20Address,
+    portalAddress,
+  };
+}
+
+/**
+ * Step 2. Deploy the L2 contracts
+ */
+async function deployToken(
+  wallet: Wallet,
+  l1Portal: EthAddress,
+): Promise<{ token: ContractDeploymentInfo; bridge: ContractDeploymentInfo }> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { TokenContract } = await import('@aztec/noir-contracts.js/Token');
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { TokenBridgeContract } = await import('@aztec/noir-contracts.js/TokenBridge');
+  const devCoin = await TokenContract.deploy(wallet, wallet.getAddress(), 'DevCoin', 'DEV', 18)
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+  const bridge = await TokenBridgeContract.deploy(wallet, devCoin.address, l1Portal)
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+
+  await new BatchCall(wallet, [
+    await devCoin.methods.set_minter(bridge.address, true).request(),
+    await devCoin.methods.set_admin(bridge.address).request(),
+  ])
+    .send()
+    .wait(waitOpts);
+
+  return {
+    token: {
+      address: devCoin.address,
+      initHash: devCoin.instance.initializationHash,
+      salt: devCoin.instance.salt,
+    },
+    bridge: {
+      address: bridge.address,
+      initHash: bridge.instance.initializationHash,
+      salt: bridge.instance.salt,
+    },
+  };
+}
+
+/**
+ * Step 3. Initialize DevCoin's L1 portal
+ */
+async function initPortal(
+  pxe: PXE,
+  { walletClient, publicClient }: L1Clients,
+  erc20: EthAddress,
+  portal: EthAddress,
+  bridge: AztecAddress,
+) {
+  const { TokenPortalAbi } = await import('@aztec/l1-artifacts');
+  const {
+    l1ContractAddresses: { registryAddress },
+  } = await pxe.getNodeInfo();
+
+  const contract = getContract({
+    abi: TokenPortalAbi,
+    address: portal.toString(),
+    client: walletClient,
+  });
+
+  const hash = await contract.write.initialize([registryAddress.toString(), erc20.toString(), bridge.toString()]);
+
+  await publicClient.waitForTransactionReceipt({ hash });
+}
+
+async function deployFPC(
+  wallet: Wallet,
+  tokenAddress: AztecAddress,
+  admin: AztecAddress,
+): Promise<ContractDeploymentInfo> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { FPCContract } = await import('@aztec/noir-contracts.js/FPC');
+  const fpc = await FPCContract.deploy(wallet, tokenAddress, admin).send({ universalDeploy: true }).deployed(waitOpts);
+  const info: ContractDeploymentInfo = {
+    address: fpc.address,
+    initHash: fpc.instance.initializationHash,
+    salt: fpc.instance.salt,
+  };
+  return info;
+}
+
+async function deployCounter(wallet: Wallet): Promise<ContractDeploymentInfo> {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+  const counter = await CounterContract.deploy(wallet, 1, wallet.getAddress())
+    .send({ universalDeploy: true })
+    .deployed(waitOpts);
+  const info: ContractDeploymentInfo = {
+    address: counter.address,
+    initHash: counter.instance.initializationHash,
+    salt: counter.instance.salt,
+  };
+  return info;
+}
+
+// NOTE: Disabling for now in order to get devnet running
+async function fundFPC(
+  counterAddress: AztecAddress,
+  wallet: Wallet,
+  l1Clients: L1Clients,
+  fpcAddress: AztecAddress,
+  debugLog: Logger,
+) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { FeeJuiceContract } = await import('@aztec/noir-contracts.js/FeeJuice');
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Importing noir-contracts.js even in devDeps results in a circular dependency error. Need to ignore because this line doesn't cause an error in a dev environment
+  const { CounterContract } = await import('@aztec/noir-contracts.js/Counter');
+  const {
+    protocolContractAddresses: { feeJuice },
+  } = await wallet.getPXEInfo();
+
+  const feeJuiceContract = await FeeJuiceContract.at(feeJuice, wallet);
+
+  const feeJuicePortal = await L1FeeJuicePortalManager.new(
+    wallet,
+    l1Clients.publicClient,
+    l1Clients.walletClient,
+    debugLog,
+  );
+
+  const amount = FEE_FUNDING_FOR_TESTER_ACCOUNT;
+  const { claimAmount, claimSecret, messageLeafIndex, messageHash } = await feeJuicePortal.bridgeTokensPublic(
+    fpcAddress,
+    amount,
+    true,
+  );
+
+  await retryUntil(
+    async () => await wallet.isL1ToL2MessageSynced(Fr.fromHexString(messageHash)),
+    'message sync',
+    600,
+    1,
+  );
+
+  const counter = await CounterContract.at(counterAddress, wallet);
+
+  debugLog.info('Incrementing Counter');
+
+  // TODO (alexg) remove this once sequencer builds blocks continuously
+  // advance the chain
+  await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+  await counter.methods.increment(wallet.getAddress(), wallet.getAddress()).send().wait(waitOpts);
+
+  debugLog.info('Claiming FPC');
+
+  await feeJuiceContract.methods
+    .claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex)
+    .send()
+    .wait({ ...waitOpts, proven: true });
+
+  debugLog.info('Finished claiming FPC');
+}

package/src/cmds/devnet/faucet.ts

@@ -0,0 +1,33 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function dripFaucet(
+  faucetUrl: string,
+  asset: string,
+  account: EthAddress,
+  json: boolean,
+  log: LogFn,
+): Promise<void> {
+  const url = new URL(`/drip/${account.toString()}`, faucetUrl);
+  url.searchParams.set('asset', asset);
+  const res = await fetch(url);
+  if (res.status === 200) {
+    if (json) {
+      log(prettyPrintJSON({ ok: true }));
+    } else {
+      log(`Dripped ${asset} for ${account.toString()}`);
+    }
+  } else {
+    if (json) {
+      log(prettyPrintJSON({ ok: false }));
+    } else if (res.status === 429) {
+      log(`Rate limited when dripping ${asset} for ${account.toString()}`);
+    } else {
+      log(`Failed to drip ${asset} for ${account.toString()}`);
+    }
+
+    process.exit(1);
+  }
+}

package/src/cmds/devnet/index.ts

@@ -0,0 +1,60 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseEthereumAddress, pxeOption } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('bootstrap-network')
+    .description('Bootstrap a new network')
+    .addOption(pxeOption)
+    .addOption(l1ChainIdOption)
+    .requiredOption<string[]>(
+      '--l1-rpc-urls <string>',
+      'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)',
+      (arg: string) => arg.split(','),
+      [ETHEREUM_HOSTS],
+    )
+    .option('--l1-private-key <string>', 'The private key to use for deployment', process.env.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(
+      '-ai, --address-index <number>',
+      'The address index to use when calculating an address',
+      arg => BigInt(arg),
+      0n,
+    )
+    .option('--json', 'Output the result as JSON')
+    .action(async options => {
+      const { bootstrapNetwork } = await import('./bootstrap_network.js');
+      await bootstrapNetwork(
+        options[pxeOption.attributeName()],
+        options.l1RpcUrls,
+        options[l1ChainIdOption.attributeName()],
+        options.l1PrivateKey,
+        options.mnemonic,
+        options.addressIndex,
+        options.json,
+        log,
+        debugLogger,
+      );
+    });
+
+  program
+    .command('drip-faucet')
+    .description('Drip the faucet')
+    .requiredOption('-u, --faucet-url <string>', 'Url of the faucet', 'http://localhost:8082')
+    .requiredOption('-t, --token <string>', 'The asset to drip', 'eth')
+    .requiredOption('-a, --address <string>', 'The Ethereum address to drip to', parseEthereumAddress)
+    .option('--json', 'Output the result as JSON')
+    .action(async options => {
+      const { dripFaucet } = await import('./faucet.js');
+      await dripFaucet(options.faucetUrl, options.token, options.address, options.json, log);
+    });
+
+  return program;
+}

package/src/cmds/infrastructure/index.ts

@@ -0,0 +1,55 @@
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import type { Command } from 'commander';
+
+import { ETHEREUM_HOSTS, l1ChainIdOption, parseOptionalInteger, pxeOption } from '../../utils/commands.js';
+
+export function injectCommands(program: Command, log: LogFn, debugLogger: Logger) {
+  program
+    .command('setup-protocol-contracts')
+    .description('Bootstrap the blockchain by initializing all the protocol contracts')
+    .addOption(pxeOption)
+    .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);
+    });
+
+  program
+    .command('sequencers')
+    .argument('<command>', 'Command to run: list, add, remove, who-next')
+    .argument('[who]', 'Who to add/remove')
+    .description('Manages or queries registered sequencers on the L1 rollup contract.')
+    .requiredOption<string[]>(
+      '--l1-rpc-urls <string>',
+      'List of Ethereum host URLs. Chain identifiers localhost and testnet can be used (comma separated)',
+      (arg: string) => arg.split(','),
+      [ETHEREUM_HOSTS],
+    )
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic for the sender of the tx',
+      '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(l1ChainIdOption)
+    .action(async (command, who, options) => {
+      const { sequencers } = await import('./sequencers.js');
+      await sequencers({
+        command: command,
+        who,
+        mnemonic: options.mnemonic,
+        rpcUrl: options.rpcUrl,
+        l1RpcUrls: options.l1RpcUrls.split(','),
+        chainId: options.l1ChainId,
+        blockNumber: options.blockNumber,
+        log,
+        debugLogger,
+      });
+    });
+
+  return program;
+}

package/src/cmds/infrastructure/sequencers.ts

@@ -0,0 +1,103 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { LogFn, Logger } 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';
+  who?: string;
+  mnemonic?: string;
+  rpcUrl: 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 { l1ContractAddresses } = await client.getNodeInfo();
+
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
+
+  const walletClient = mnemonic
+    ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map(url => http(url))),
+      })
+    : undefined;
+
+  const rollup = getContract({
+    address: l1ContractAddresses.rollupAddress.toString(),
+    abi: RollupAbi,
+    client: publicClient,
+  });
+
+  const writeableRollup = walletClient
+    ? getContract({
+        address: l1ContractAddresses.rollupAddress.toString(),
+        abi: RollupAbi,
+        client: walletClient,
+      })
+    : undefined;
+
+  const who = (maybeWho as `0x{string}`) ?? walletClient?.account.address.toString();
+
+  if (command === 'list') {
+    const sequencers = await rollup.read.getAttesters();
+    if (sequencers.length === 0) {
+      log(`No sequencers registered on rollup`);
+    } else {
+      log(`Registered sequencers on rollup:`);
+      for (const sequencer of sequencers) {
+        log(' ' + sequencer.toString());
+      }
+    }
+  } else if (command === 'add') {
+    if (!who || !writeableRollup || !walletClient) {
+      throw new Error(`Missing sequencer address`);
+    }
+
+    log(`Adding ${who} as sequencer`);
+
+    const stakingAsset = getContract({
+      address: await rollup.read.getStakingAsset(),
+      abi: TestERC20Abi,
+      client: walletClient,
+    });
+
+    const config = getL1ContractsConfigEnvVars();
+
+    await Promise.all(
+      [
+        await stakingAsset.write.mint([walletClient.account.address, config.minimumStake], {} as any),
+        await stakingAsset.write.approve([rollup.address, config.minimumStake], {} as any),
+      ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+    );
+
+    const hash = await writeableRollup.write.deposit([who, who, who, config.minimumStake]);
+    await publicClient.waitForTransactionReceipt({ hash });
+    log(`Added in tx ${hash}`);
+  } else if (command === 'remove') {
+    if (!who || !writeableRollup) {
+      throw new Error(`Missing sequencer address`);
+    }
+    log(`Removing ${who} as sequencer`);
+    const hash = await writeableRollup.write.initiateWithdraw([who, who]);
+    await publicClient.waitForTransactionReceipt({ hash });
+    log(`Removed in tx ${hash}`);
+  } else if (command === 'who-next') {
+    const next = await rollup.read.getCurrentProposer();
+    log(`Sequencer expected to build is ${next}`);
+  } else {
+    throw new Error(`Unknown command ${command}`);
+  }
+}

package/src/cmds/infrastructure/setup_l2_contract.ts

@@ -0,0 +1,47 @@
+import { type InitialAccountData, deployFundedSchnorrAccounts, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { type AztecAddress, SignerlessWallet, type WaitOpts, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
+import type { LogFn } from '@aztec/foundation/log';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+
+import { setupCanonicalL2FeeJuice } from '../misc/setup_contracts.js';
+
+export async function setupL2Contracts(
+  rpcUrl: string,
+  testAccounts: boolean,
+  json: boolean,
+  skipProofWait: 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);
+
+  let deployedAccounts: InitialAccountData[] = [];
+  if (testAccounts) {
+    log('setupL2Contracts: Deploying test accounts...');
+    deployedAccounts = await getInitialTestAccounts();
+    await deployFundedSchnorrAccounts(pxe, deployedAccounts, waitOpts);
+  }
+
+  if (json) {
+    const toPrint: Record<string, AztecAddress> = { ...ProtocolContractAddress };
+    deployedAccounts.forEach((a, i) => {
+      toPrint[`testAccount${i}`] = a.address;
+    });
+    log(JSON.stringify(toPrint, null, 2));
+  }
+}

package/src/cmds/l1/advance_epoch.ts

@@ -0,0 +1,12 @@
+import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+
+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);
+
+  const cheat = CheatCodes.createRollup(l1RpcUrls, { rollupAddress });
+
+  await cheat.advanceToNextEpoch();
+  log(`Warped time to advance to next epoch`);
+}

package/src/cmds/l1/assume_proven_through.ts

@@ -0,0 +1,19 @@
+import { EthCheatCodes, RollupCheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import type { LogFn } from '@aztec/foundation/log';
+
+export async function assumeProvenThrough(
+  blockNumberOrLatest: number | undefined,
+  l1RpcUrls: string[],
+  rpcUrl: 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 ethCheatCode = new EthCheatCodes(l1RpcUrls);
+  const rollupCheatCodes = new RollupCheatCodes(ethCheatCode, { rollupAddress });
+
+  await rollupCheatCodes.markAsProven(blockNumber);
+  log(`Assumed proven through block ${blockNumber}`);
+}