@aztec-labs/cli 6.0.0-nightly.20260829

package/src/cmds/infrastructure/sequencers.ts

@@ -0,0 +1,122 @@
+import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { createAztecNodeClient } from '@aztec-labs/aztec.js/node';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { GSEContract, RollupContract } from '@aztec-labs/ethereum/contracts';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
+import { mnemonicToAccount } from 'viem/accounts';
+
+export async function sequencers(opts: {
+  command: 'list' | 'add' | 'remove' | 'who-next' | 'flush';
+  who?: string;
+  mnemonic?: string;
+  bn254SecretKey?: bigint;
+  nodeUrl: string;
+  l1RpcUrls: string[];
+  chainId: number;
+  log: LogFn;
+}) {
+  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, { batch: false }))),
+  });
+
+  const walletClient = mnemonic
+    ? createWalletClient({
+        account: mnemonicToAccount(mnemonic),
+        chain: chain.chainInfo,
+        transport: fallback(l1RpcUrls.map(url => http(url, { batch: false }))),
+      })
+    : undefined;
+
+  const rollup = new RollupContract(publicClient, l1ContractAddresses.rollupAddress);
+
+  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.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 stakingAssetAddress = await rollup.getStakingAsset();
+    const stakingAsset = getContract({
+      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.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,
+      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`);
+    }
+    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.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,40 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import type { WaitOpts } from '@aztec-labs/aztec.js/contracts';
+import { createAztecNodeClient } from '@aztec-labs/aztec.js/node';
+import { TxStatus } from '@aztec-labs/aztec.js/tx';
+import { AccountManager } from '@aztec-labs/aztec.js/wallet';
+import { jsonStringify } from '@aztec-labs/foundation/json-rpc';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { ProtocolContractAddress } from '@aztec-labs/protocol-contracts';
+import { EmbeddedWallet } from '@aztec-labs/wallets/embedded';
+import { createFundedInitializerlessAccounts } from '@aztec-labs/wallets/testing';
+
+export async function setupL2Contracts(nodeUrl: string, testAccounts: boolean, json: boolean, log: LogFn) {
+  const waitOpts: WaitOpts = {
+    timeout: 180,
+    interval: 1,
+    // The embedded wallet defaults to PROPOSED, which can be dropped if its proposed block is pruned
+    // before the checkpoint lands. Wait for the checkpoint so serial setup is reliable.
+    waitForStatus: TxStatus.CHECKPOINTED,
+  };
+  log('setupL2Contracts: Wait options' + jsonStringify(waitOpts));
+  log('setupL2Contracts: Creating PXE client...');
+  const node = createAztecNodeClient(nodeUrl);
+  const wallet = await EmbeddedWallet.create(node);
+
+  let accountManagers: AccountManager[] = [];
+  if (testAccounts) {
+    log('setupL2Contracts: Creating test accounts...');
+    const initialAccountsData = await getInitialTestAccountsData();
+    accountManagers = await createFundedInitializerlessAccounts(wallet, initialAccountsData);
+  }
+
+  if (json) {
+    const toPrint: Record<string, AztecAddress> = { ...ProtocolContractAddress };
+    accountManagers.forEach((a, i) => {
+      toPrint[`testAccount${i}`] = a.address;
+    });
+    log(JSON.stringify(toPrint, null, 2));
+  }
+}

package/src/cmds/l1/advance_epoch.ts

@@ -0,0 +1,14 @@
+import { createAztecNodeClient } from '@aztec-labs/aztec.js/node';
+import { RollupCheatCodes } from '@aztec-labs/ethereum/test';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+
+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 = 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

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

package/src/cmds/l1/compute_genesis_values.ts

@@ -0,0 +1,29 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { getGenesisValues } from '@aztec-labs/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-labs/noir-protocol-circuits-types/vk-tree');
+  const vkTreeRoot = getVKTreeRoot();
+
+  log(
+    JSON.stringify(
+      {
+        vkTreeRoot: vkTreeRoot.toString(),
+        protocolContractsHash: protocolContractsHash.toString(),
+        genesisArchiveRoot: genesisArchiveRoot.toString(),
+      },
+      null,
+      2,
+    ),
+  );
+}

package/src/cmds/l1/create_l1_account.ts

@@ -0,0 +1,16 @@
+import type { LogFn } from '@aztec-labs/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_cmd.ts

@@ -0,0 +1,105 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import type { EthAddress } from '@aztec-labs/aztec.js/addresses';
+import { Fr } from '@aztec-labs/aztec.js/fields';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import { type Operator, deployAztecL1Contracts } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import { SecretValue } from '@aztec-labs/foundation/config';
+import type { LogFn, Logger } from '@aztec-labs/foundation/log';
+import { protocolContractsHash } from '@aztec-labs/protocol-contracts';
+import { getGenesisValues } from '@aztec-labs/world-state/testing';
+import { mnemonicToAccount } from 'viem/accounts';
+
+import { addLeadingHex } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+
+export async function deployL1ContractsCmd(
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  testAccounts: boolean,
+  sponsoredFPC: boolean,
+  json: boolean,
+  initialValidators: EthAddress[],
+  realVerifier: boolean,
+  existingToken: EthAddress | undefined,
+  log: LogFn,
+  debugLogger: Logger,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  // Compute initial accounts for genesis (test accounts + sponsored FPC)
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+  const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+  const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
+  const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
+
+  // Get the VK tree root
+  const { getVKTreeRoot } = await import('@aztec-labs/noir-protocol-circuits-types/vk-tree');
+  const vkTreeRoot = getVKTreeRoot();
+
+  // Get private key (from direct input or mnemonic)
+  let deployerPrivateKey: `0x${string}`;
+  if (privateKey) {
+    deployerPrivateKey = addLeadingHex(privateKey);
+  } else {
+    const account = mnemonicToAccount(mnemonic!, { addressIndex: mnemonicIndex });
+    deployerPrivateKey = `0x${Buffer.from(account.getHdKey().privateKey!).toString('hex')}`;
+  }
+
+  // Prepare validator operators with bn254 keys
+  const initialValidatorOperators: Operator[] = initialValidators.map(a => ({
+    attester: a,
+    withdrawer: a,
+    bn254SecretKey: new SecretValue(Fr.random().toBigInt()),
+  }));
+
+  debugLogger.info('Deploying L1 contracts via Forge...');
+
+  // Deploy using l1-contracts Forge scripts
+  const { l1ContractAddresses, rollupVersion } = await deployAztecL1Contracts(rpcUrls[0], deployerPrivateKey, chainId, {
+    // Initial validators to add during deployment
+    initialValidators: initialValidatorOperators,
+    // Genesis config
+    vkTreeRoot,
+    protocolContractsHash,
+    genesisArchiveRoot,
+    // Deployment options
+    realVerifier,
+    ...config,
+    feeJuicePortalInitialBalance: fundingNeeded,
+    existingTokenAddress: existingToken,
+  });
+
+  debugLogger.info('Forge deployment complete', { rollupVersion });
+
+  if (json) {
+    log(
+      JSON.stringify(
+        Object.fromEntries(Object.entries(l1ContractAddresses).map(([k, v]) => [k, v?.toString() ?? 'Not deployed'])),
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Rollup Address: ${l1ContractAddresses.rollupAddress.toString()}`);
+    log(`Registry Address: ${l1ContractAddresses.registryAddress.toString()}`);
+    log(`GSE Address: ${l1ContractAddresses.gseAddress?.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(`FeeAssetHandler Address: ${l1ContractAddresses.feeAssetHandlerAddress?.toString()}`);
+    log(`StakingAssetHandler Address: ${l1ContractAddresses.stakingAssetHandlerAddress?.toString()}`);
+    log(`ZK Passport Verifier Address: ${l1ContractAddresses.zkPassportVerifierAddress?.toString()}`);
+    log(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+    log(`Initial validators: ${initialValidators.map(a => a.toString()).join(', ')}`);
+    log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+  }
+}

package/src/cmds/l1/deploy_new_rollup.ts

@@ -0,0 +1,65 @@
+import { getInitialTestAccountsData } from '@aztec-labs/accounts/testing';
+import { getL1ContractsConfigEnvVars } from '@aztec-labs/ethereum/config';
+import type { Operator } from '@aztec-labs/ethereum/deploy-aztec-l1-contracts';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { getGenesisValues } from '@aztec-labs/world-state/testing';
+
+import { deployNewRollupContracts } from '../../utils/aztec.js';
+import { getSponsoredFPCAddress } from '../../utils/setup_contracts.js';
+
+export async function deployNewRollup(
+  registryAddress: EthAddress,
+  rpcUrls: string[],
+  chainId: number,
+  privateKey: string | undefined,
+  mnemonic: string,
+  mnemonicIndex: number,
+  testAccounts: boolean,
+  sponsoredFPC: boolean,
+  json: boolean,
+  initialValidators: Operator[],
+  realVerifier: boolean,
+  log: LogFn,
+) {
+  const config = getL1ContractsConfigEnvVars();
+
+  const initialAccounts = testAccounts ? await getInitialTestAccountsData() : [];
+  const sponsoredFPCAddress = sponsoredFPC ? await getSponsoredFPCAddress() : [];
+  const initialFundedAccounts = initialAccounts.map(a => a.address).concat(sponsoredFPCAddress);
+  const { genesisArchiveRoot, fundingNeeded } = await getGenesisValues(initialFundedAccounts);
+
+  const { rollup } = await deployNewRollupContracts(
+    registryAddress,
+    rpcUrls,
+    privateKey,
+    chainId,
+    mnemonic,
+    mnemonicIndex,
+    initialValidators,
+    genesisArchiveRoot,
+    fundingNeeded,
+    config,
+    realVerifier,
+  );
+
+  if (json) {
+    log(
+      JSON.stringify(
+        {
+          rollupAddress: rollup.address,
+          initialFundedAccounts: initialFundedAccounts.map(a => a.toString()),
+          initialValidators: initialValidators.map(a => a.attester.toString()),
+          genesisArchiveRoot: genesisArchiveRoot.toString(),
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    log(`Rollup Address: ${rollup.address}`);
+    log(`Initial funded accounts: ${initialFundedAccounts.map(a => a.toString()).join(', ')}`);
+    log(`Initial validators: ${initialValidators.map(a => a.attester.toString()).join(', ')}`);
+    log(`Genesis archive root: ${genesisArchiveRoot.toString()}`);
+  }
+}

package/src/cmds/l1/get_l1_addresses.ts

@@ -0,0 +1,31 @@
+import { EthAddress } from '@aztec-labs/aztec.js/addresses';
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { RegistryContract } from '@aztec-labs/ethereum/contracts';
+import type { ViemPublicClient } from '@aztec-labs/ethereum/types';
+import type { LogFn } from '@aztec-labs/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, { batch: false }))),
+    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 { TestERC20Abi } from '@aztec/l1-artifacts';
+
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { LogFn } from '@aztec-labs/foundation/log';
+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, { batch: false }))),
+  });
+
+  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,183 @@
+import { createEthereumChain } from '@aztec-labs/ethereum/chain';
+import { createExtendedL1Client } from '@aztec-labs/ethereum/client';
+import { FeeJuiceContract, GovernanceContract, ProposalState, RegistryContract } from '@aztec-labs/ethereum/contracts';
+import type { LogFn, Logger } from '@aztec-labs/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 extendedClient = createExtendedL1Client(
+    rpcUrls,
+    privateKey ?? mnemonic,
+    chain.chainInfo,
+    undefined,
+    mnemonicIndex,
+  );
+
+  const addresses = await RegistryContract.collectAddresses(extendedClient, registryAddress, 'canonical');
+  const governanceAddress = addresses.governanceAddress.toString();
+  const tokenAddress = addresses.stakingAssetAddress.toString();
+
+  const feeJuice = new FeeJuiceContract(tokenAddress, extendedClient);
+  const governance = new GovernanceContract(governanceAddress, extendedClient);
+  if (mint) {
+    await feeJuice.mint(recipient, amount);
+    debugLogger.info(`Minted ${amount} tokens to ${recipient}`);
+  }
+
+  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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+  const governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, client);
+
+  const proposalId = await governance.proposeWithLock({
+    payloadAddress,
+    withdrawAddress: client.account.address,
+  });
+  if (json) {
+    log(JSON.stringify({ proposalId: Number(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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+  const governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, client);
+  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 client = createExtendedL1Client(rpcUrls, privateKey ?? mnemonic, chain.chainInfo, undefined, mnemonicIndex);
+
+  const addresses = await RegistryContract.collectAddresses(client, registryAddress, 'canonical');
+  const governanceAddress = addresses.governanceAddress.toString();
+
+  const governance = new GovernanceContract(governanceAddress, client);
+  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 });
+}