@aztec/cli 0.17.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/src/cmds/devnet/bootstrap_network.ts

@@ -0,0 +1,306 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import {
+  BatchCall,
+  L1FeeJuicePortalManager,
+  type PXE,
+  type WaitOpts,
+  type Wallet,
+  createCompatibleClient,
+  retryUntil,
+} from '@aztec/aztec.js';
+import { type AztecAddress, type EthAddress, FEE_FUNDING_FOR_TESTER_ACCOUNT, Fq, Fr } from '@aztec/circuits.js';
+import {
+  type ContractArtifacts,
+  type L1Clients,
+  createEthereumChain,
+  createL1Clients,
+  deployL1Contract,
+} from '@aztec/ethereum';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { getContract } from 'viem';
+import { 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,
+  l1Url: string,
+  l1ChainId: string,
+  l1PrivateKey: `0x${string}` | undefined,
+  l1Mnemonic: string,
+  json: boolean,
+  log: LogFn,
+  debugLog: Logger,
+) {
+  const pxe = await createCompatibleClient(pxeUrl, debugLog);
+
+  // setup a one-off account contract
+  const account = await getSchnorrAccount(pxe, Fr.random(), Fq.random(), Fr.random());
+  const wallet = await account.deploy().getWallet();
+
+  const l1Clients = createL1Clients(
+    l1Url,
+    l1PrivateKey ? privateKeyToAccount(l1PrivateKey) : l1Mnemonic,
+    createEthereumChain(l1Url, +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);
+  // NOTE: Disabling for now in order to get devnet running
+  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);
+
+  // 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);
+
+  await feeJuiceContract.methods
+    .claim(fpcAddress, claimAmount, claimSecret, messageLeafIndex)
+    .send()
+    .wait({ ...waitOpts, proven: true });
+}

package/src/cmds/devnet/faucet.ts

@@ -0,0 +1,33 @@
+import { type EthAddress } from '@aztec/circuits.js';
+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,52 @@
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { type Command } from 'commander';
+
+import { ETHEREUM_HOST, 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(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .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('--json', 'Output the result as JSON')
+    .action(async options => {
+      const { bootstrapNetwork } = await import('./bootstrap_network.js');
+      await bootstrapNetwork(
+        options[pxeOption.attributeName()],
+        options.l1RpcUrl,
+        options[l1ChainIdOption.attributeName()],
+        options.l1PrivateKey,
+        options.mnemonic,
+        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,54 @@
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { type Command } from 'commander';
+
+import { ETHEREUM_HOST, 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)
+    .addOption(l1ChainIdOption)
+    .option('--json', 'Output the contract addresses in JSON format')
+    .option('--skipProofWait', "Don't wait for proofs to land.")
+    .action(async options => {
+      const { setupProtocolContracts } = await import('./setup_protocol_contract.js');
+      await setupProtocolContracts(options.rpcUrl, options.l1ChainId, 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(
+      '--l1-rpc-url <string>',
+      'Url of the ethereum host. Chain identifiers localhost and testnet can be used',
+      ETHEREUM_HOST,
+    )
+    .option(
+      '-m, --mnemonic <string>',
+      'The mnemonic 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,
+        l1RpcUrl: options.l1RpcUrl,
+        chainId: options.l1ChainId,
+        blockNumber: options.blockNumber,
+        log,
+        debugLogger,
+      });
+    });
+
+  return program;
+}

package/src/cmds/infrastructure/sequencers.ts

@@ -0,0 +1,100 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, createWalletClient, 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;
+  l1RpcUrl: string;
+  chainId: number;
+  blockNumber?: number;
+  log: LogFn;
+  debugLogger: Logger;
+}) {
+  const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrl, chainId, log, debugLogger } = opts;
+  const client = await createCompatibleClient(rpcUrl, debugLogger);
+  const { l1ContractAddresses } = await client.getNodeInfo();
+
+  const chain = createEthereumChain(l1RpcUrl, chainId);
+  const publicClient = createPublicClient({ chain: chain.chainInfo, transport: http(chain.rpcUrl) });
+
+  const walletClient = mnemonic
+    ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: http(chain.rpcUrl),
+      })
+    : 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_protocol_contract.ts

@@ -0,0 +1,36 @@
+import { SignerlessWallet, type WaitOpts, createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { DefaultMultiCallEntrypoint } from '@aztec/aztec.js/entrypoint';
+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 setupProtocolContracts(
+  rpcUrl: string,
+  l1ChainId: number,
+  json: boolean,
+  skipProofWait: boolean,
+  log: LogFn,
+) {
+  const waitOpts: WaitOpts = {
+    timeout: 180,
+    interval: 1,
+    proven: !skipProofWait,
+    provenTimeout: 600,
+  };
+  log('setupProtocolContracts: Wait options' + jsonStringify(waitOpts));
+  log('setupProtocolContracts: Creating PXE client...');
+  const pxe = createPXEClient(rpcUrl, makeFetch([1, 1, 1, 1, 1], false));
+  const wallet = new SignerlessWallet(pxe, new DefaultMultiCallEntrypoint(l1ChainId, 1));
+
+  log('setupProtocolContracts: Getting fee juice portal address...');
+  // Deploy Fee Juice
+  const feeJuicePortalAddress = (await wallet.getNodeInfo()).l1ContractAddresses.feeJuicePortalAddress;
+  log('setupProtocolContracts: Setting up fee juice portal...');
+  await setupCanonicalL2FeeJuice(wallet, feeJuicePortalAddress, waitOpts, log);
+
+  if (json) {
+    log(JSON.stringify(ProtocolContractAddress, 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(l1RpcUrl: 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(l1RpcUrl, { rollupAddress });
+
+  await cheat.advanceToNextEpoch();
+  log(`Warped time to advance to next epoch`);
+}

package/src/cmds/l1/assume_proven_through.ts

@@ -0,0 +1,25 @@
+import { createPXEClient, makeFetch } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { type LogFn } from '@aztec/foundation/log';
+
+import { setAssumeProvenThrough } from '../../utils/aztec.js';
+
+export async function assumeProvenThrough(
+  blockNumberOrLatest: number | undefined,
+  l1RpcUrl: string,
+  rpcUrl: string,
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(l1RpcUrl, chainId);
+  const { walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+
+  const pxe = createPXEClient(rpcUrl, makeFetch([], true));
+  const rollupAddress = await pxe.getNodeInfo().then(i => i.l1ContractAddresses.rollupAddress);
+  const blockNumber = blockNumberOrLatest ?? (await pxe.getBlockNumber());
+
+  await setAssumeProvenThrough(blockNumber, rollupAddress, walletClient);
+  log(`Assumed proven through block ${blockNumber}`);
+}

package/src/cmds/l1/bridge_erc20.ts

@@ -0,0 +1,53 @@
+import { L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import { type AztecAddress, type EthAddress, type Fr } from '@aztec/circuits.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { type LogFn, type Logger } from '@aztec/foundation/log';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function bridgeERC20(
+  amount: bigint,
+  recipient: AztecAddress,
+  l1RpcUrl: string,
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  tokenAddress: EthAddress,
+  portalAddress: EthAddress,
+  privateTransfer: boolean,
+  mint: boolean,
+  json: boolean,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  // Prepare L1 client
+  const chain = createEthereumChain(l1RpcUrl, chainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+
+  // Setup portal manager
+  const manager = new L1ToL2TokenPortalManager(portalAddress, tokenAddress, publicClient, walletClient, debugLogger);
+  let claimSecret: Fr;
+  let messageHash: `0x${string}`;
+  if (privateTransfer) {
+    ({ claimSecret, messageHash } = await manager.bridgeTokensPrivate(recipient, amount, mint));
+  } else {
+    ({ claimSecret, messageHash } = await manager.bridgeTokensPublic(recipient, amount, mint));
+  }
+
+  if (json) {
+    log(
+      prettyPrintJSON({
+        claimAmount: amount,
+        claimSecret: claimSecret,
+      }),
+    );
+  } else {
+    if (mint) {
+      log(`Minted ${amount} tokens on L1 and pushed to L2 portal`);
+    } else {
+      log(`Bridged ${amount} tokens to L2 portal`);
+    }
+    log(`claimAmount=${amount},claimSecret=${claimSecret}\n,messageHash=${messageHash}`);
+    log(`Note: You need to wait for two L2 blocks before pulling them from the L2 side`);
+  }
+}

package/src/cmds/l1/create_l1_account.ts

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