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

package/src/cmds/l1/bridge_erc20.ts

@@ -0,0 +1,52 @@
+import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function bridgeERC20(
+  amount: bigint,
+  recipient: AztecAddress,
+  l1RpcUrls: 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(l1RpcUrls, chainId);
+  const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, 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}`);
+  }
+}

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -0,0 +1,63 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { deployAztecContracts } from '../../utils/aztec.js';
+
+export async function deployL1Contracts(
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  salt: number | undefined,
+  testAccounts: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+
+  const { l1ContractAddresses } = await deployAztecContracts(
+    rpcUrls,
+    chainId,
+    privateKey,
+    mnemonic,
+    mnemonicIndex,
+    salt,
+    initialValidators,
+    genesisArchiveRoot,
+    genesisBlockHash,
+    config,
+    debugLogger,
+  );
+
+  if (json) {
+    log(
+      JSON.stringify(
+        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v.toString()])),
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+    log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+    log(`L1 -> L2 Inbox Address: ${l1ContractAddresses.inboxAddress.toString()}`);
+    log(`L2 -> L1 Outbox Address: ${l1ContractAddresses.outboxAddress.toString()}`);
+    log(`Fee Juice Address: ${l1ContractAddresses.feeJuiceAddress.toString()}`);
+    log(`Staking Asset Address: ${l1ContractAddresses.stakingAssetAddress.toString()}`);
+    log(`Fee Juice Portal Address: ${l1ContractAddresses.feeJuicePortalAddress.toString()}`);
+    log(`CoinIssuer Address: ${l1ContractAddresses.coinIssuerAddress.toString()}`);
+    log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
+    log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
+    log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
+    log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress?.toString()}`);
+  }
+}

package/src/cmds/l1/deploy_l1_verifier.ts

@@ -0,0 +1,105 @@
+import { createCompatibleClient } from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { HonkVerifierAbi, HonkVerifierBytecode } from '@aztec/l1-artifacts';
+
+import { InvalidOptionArgumentError } from 'commander';
+import { type Hex, getContract } from 'viem';
+
+export async function deployUltraHonkVerifier(
+  rollupAddress: Hex | undefined,
+  ethRpcUrls: string[],
+  l1ChainId: string,
+  privateKey: string | undefined,
+  mnemonic: string,
+  pxeRpcUrl: string,
+  bbBinaryPath: string,
+  bbWorkingDirectory: string,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  if (!bbBinaryPath || !bbWorkingDirectory) {
+    throw new InvalidOptionArgumentError('Missing path to bb binary and working directory');
+  }
+
+  const { publicClient, walletClient } = createL1Clients(
+    ethRpcUrls,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrls, l1ChainId).chainInfo,
+  );
+
+  if (!rollupAddress && pxeRpcUrl) {
+    const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+    const { l1ContractAddresses } = await pxe.getNodeInfo();
+    rollupAddress = l1ContractAddresses.rollupAddress.toString();
+  }
+
+  if (!rollupAddress) {
+    throw new InvalidOptionArgumentError('Missing rollup address');
+  }
+
+  const { RollupAbi } = await import('@aztec/l1-artifacts');
+
+  const rollup = getContract({
+    abi: RollupAbi,
+    address: rollupAddress,
+    client: walletClient,
+  });
+
+  const { address: verifierAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    HonkVerifierAbi,
+    HonkVerifierBytecode,
+  );
+  log(`Deployed honk verifier at ${verifierAddress}`);
+
+  await rollup.write.setEpochVerifier([verifierAddress.toString()]);
+
+  log(`Rollup accepts only real proofs now`);
+}
+
+export async function deployMockVerifier(
+  rollupAddress: Hex | undefined,
+  ethRpcUrls: string[],
+  l1ChainId: string,
+  privateKey: string | undefined,
+  mnemonic: string,
+  pxeRpcUrl: string,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const { publicClient, walletClient } = createL1Clients(
+    ethRpcUrls,
+    privateKey ?? mnemonic,
+    createEthereumChain(ethRpcUrls, l1ChainId).chainInfo,
+  );
+  const { MockVerifierAbi, MockVerifierBytecode, RollupAbi } = await import('@aztec/l1-artifacts');
+
+  const { address: mockVerifierAddress } = await deployL1Contract(
+    walletClient,
+    publicClient,
+    MockVerifierAbi,
+    MockVerifierBytecode,
+  );
+  log(`Deployed MockVerifier at ${mockVerifierAddress.toString()}`);
+
+  if (!rollupAddress && pxeRpcUrl) {
+    const pxe = await createCompatibleClient(pxeRpcUrl, debugLogger);
+    const { l1ContractAddresses } = await pxe.getNodeInfo();
+    rollupAddress = l1ContractAddresses.rollupAddress.toString();
+  }
+
+  if (!rollupAddress) {
+    throw new InvalidOptionArgumentError('Missing rollup address');
+  }
+
+  const rollup = getContract({
+    abi: RollupAbi,
+    address: rollupAddress,
+    client: walletClient,
+  });
+
+  await rollup.write.setEpochVerifier([mockVerifierAddress.toString()]);
+  log(`Rollup accepts only fake proofs now`);
+}

package/src/cmds/l1/deploy_new_rollup.ts

@@ -0,0 +1,58 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+import { getGenesisValues } from '@aztec/world-state/testing';
+
+import { deployNewRollupContracts } from '../../utils/aztec.js';
+
+export async function deployNewRollup(
+  registryAddress: EthAddress,
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  salt: number | undefined,
+  testAccounts: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  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,
+  );
+
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          payloadAddress: payloadAddress.toString(),
+          rollupAddress: rollup.address,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Payload Address: ${payloadAddress.toString()}`);
+    log(`Rollup Address: ${rollup.address}`);
+  }
+}

package/src/cmds/l1/get_l1_addresses.ts

@@ -0,0 +1,30 @@
+import { EthAddress } from '@aztec/aztec.js';
+import { RegistryContract, type ViemPublicClient, createEthereumChain } from '@aztec/ethereum';
+import type { LogFn } from '@aztec/foundation/log';
+
+import { createPublicClient, fallback, http } from 'viem';
+
+export async function getL1Addresses(
+  registryAddress: EthAddress,
+  rollupVersion: number | bigint | 'canonical',
+  rpcUrls: string[],
+  chainId: number,
+  json: boolean,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(rpcUrls, chainId);
+  const publicClient: ViemPublicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(rpcUrls.map(url => http(url))),
+    pollingInterval: 100,
+  });
+  const addresses = await RegistryContract.collectAddresses(publicClient, registryAddress.toString(), rollupVersion);
+
+  if (json) {
+    log(JSON.stringify(addresses, null, 2));
+  } else {
+    for (const [key, value] of Object.entries(addresses)) {
+      log(`${key}: ${value.toString()}`);
+    }
+  }
+}

package/src/cmds/l1/get_l1_balance.ts

@@ -0,0 +1,44 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createPublicClient, fallback, getContract, http } from 'viem';
+
+import { prettyPrintJSON } from '../../utils/commands.js';
+
+export async function getL1Balance(
+  who: EthAddress,
+  token: EthAddress | undefined,
+  l1RpcUrls: string[],
+  chainId: number,
+  json: boolean,
+  log: LogFn,
+) {
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
+
+  let balance = 0n;
+  if (token) {
+    const gasL1 = getContract({
+      address: token.toString(),
+      abi: TestERC20Abi,
+      client: publicClient,
+    });
+
+    balance = await gasL1.read.balanceOf([who.toString()]);
+  } else {
+    balance = await publicClient.getBalance({
+      address: who.toString(),
+    });
+  }
+
+  if (json) {
+    log(prettyPrintJSON({ balance }));
+  } else {
+    log(`L1 balance of ${who.toString()} is ${balance.toString()}`);
+  }
+}

package/src/cmds/l1/governance_utils.ts

@@ -0,0 +1,187 @@
+import {
+  FeeJuiceContract,
+  GovernanceContract,
+  ProposalState,
+  RegistryContract,
+  createEthereumChain,
+  createL1Clients,
+} from '@aztec/ethereum';
+import type { LogFn, Logger } from '@aztec/foundation/log';
+
+export async function depositGovernanceTokens({
+  registryAddress,
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  mnemonicIndex,
+  recipient,
+  amount,
+  debugLogger,
+  mint,
+}: {
+  registryAddress: `0x${string}`;
+  rpcUrls: string[];
+  chainId: number;
+  privateKey: string | undefined;
+  mnemonic: string;
+  mnemonicIndex: number;
+  recipient: `0x${string}`;
+  amount: bigint;
+  debugLogger: Logger;
+  mint: boolean;
+}) {
+  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 governanceAddress = addresses.governanceAddress.toString();
+  const tokenAddress = addresses.feeJuiceAddress.toString();
+
+  const feeJuice = new FeeJuiceContract(tokenAddress, publicClient, walletClient);
+  const governance = new GovernanceContract(governanceAddress, publicClient, walletClient);
+  if (mint) {
+    await feeJuice.mint(recipient, amount);
+    debugLogger.info(`Minted ${amount} tokens to ${recipient}`);
+  }
+
+  await feeJuice.approve(governanceAddress, amount);
+  debugLogger.info(`Approved ${amount} tokens for governance`);
+
+  await governance.deposit(recipient, amount);
+  debugLogger.info(`Deposited ${amount} tokens to ${recipient}`);
+}
+
+export async function proposeWithLock({
+  payloadAddress,
+  registryAddress,
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  mnemonicIndex,
+  json,
+  debugLogger,
+  log,
+}: {
+  payloadAddress: `0x${string}`;
+  registryAddress: `0x${string}`;
+  rpcUrls: string[];
+  chainId: number;
+  privateKey: string | undefined;
+  mnemonic: string;
+  mnemonicIndex: number;
+  debugLogger: Logger;
+  log: LogFn;
+  json: boolean;
+}) {
+  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 governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+
+  const proposalId = await governance.proposeWithLock({
+    payloadAddress,
+    withdrawAddress: clients.walletClient.account.address,
+  });
+  if (json) {
+    log(JSON.stringify({ proposalId }, null, 2));
+  } else {
+    log(`Proposed with lock`);
+    log(`Proposal ID: ${proposalId}`);
+  }
+}
+
+export async function voteOnGovernanceProposal({
+  proposalId,
+  voteAmount,
+  inFavor,
+  waitTilActive,
+  registryAddress,
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  mnemonicIndex,
+  debugLogger,
+}: {
+  proposalId: bigint;
+  voteAmount: bigint | undefined;
+  inFavor: boolean;
+  waitTilActive: boolean;
+  registryAddress: `0x${string}`;
+  rpcUrls: string[];
+  chainId: number;
+  privateKey: string | undefined;
+  mnemonic: string;
+  mnemonicIndex: number;
+  debugLogger: Logger;
+}) {
+  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 governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+  const state = await governance.getProposalState(proposalId);
+  if (state !== ProposalState.Active && !waitTilActive) {
+    debugLogger.warn(`Proposal is not active, but waitTilActive is false. Not voting.`);
+    return;
+  }
+
+  await governance.awaitProposalActive({ proposalId, logger: debugLogger });
+  await governance.vote({ proposalId, voteAmount, inFavor, retries: 10, logger: debugLogger });
+}
+
+export async function executeGovernanceProposal({
+  proposalId,
+  waitTilExecutable,
+  registryAddress,
+  rpcUrls,
+  chainId,
+  privateKey,
+  mnemonic,
+  mnemonicIndex,
+  debugLogger,
+}: {
+  proposalId: bigint;
+  waitTilExecutable: boolean;
+  registryAddress: `0x${string}`;
+  rpcUrls: string[];
+  chainId: number;
+  privateKey: string | undefined;
+  mnemonic: string;
+  mnemonicIndex: number;
+  debugLogger: Logger;
+}) {
+  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 governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, clients.publicClient, clients.walletClient);
+  const state = await governance.getProposalState(proposalId);
+  if (state !== ProposalState.Executable && !waitTilExecutable) {
+    debugLogger.warn(`Proposal is not executable, but waitTilExecutable is false. Not executing.`);
+    return;
+  }
+
+  await governance.awaitProposalExecutable({ proposalId, logger: debugLogger });
+  await governance.executeProposal({ proposalId, retries: 10, logger: debugLogger });
+}