@aztec/cli 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.77.0-testnet-ignition.21

package/src/cmds/infrastructure/sequencers.ts

@@ -1,9 +1,9 @@
 import { createCompatibleClient } from '@aztec/aztec.js';
 import { createEthereumChain, getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import { type LogFn, type Logger } from '@aztec/foundation/log';
+import type { LogFn, Logger } from '@aztec/foundation/log';
 import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
 
-import { createPublicClient, createWalletClient, getContract, http } from 'viem';
+import { createPublicClient, createWalletClient, fallback, getContract, http } from 'viem';
 import { mnemonicToAccount } from 'viem/accounts';
 
 export async function sequencers(opts: {
@@ -11,24 +11,27 @@ export async function sequencers(opts: {
   who?: string;
   mnemonic?: string;
   rpcUrl: string;
-  l1RpcUrl: string;
+  l1RpcUrls: string[];
   chainId: number;
   blockNumber?: number;
   log: LogFn;
   debugLogger: Logger;
 }) {
-  const { command, who: maybeWho, mnemonic, rpcUrl, l1RpcUrl, chainId, log, debugLogger } = opts;
+  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(l1RpcUrl, chainId);
-  const publicClient = createPublicClient({ chain: chain.chainInfo, transport: http(chain.rpcUrl) });
+  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: http(chain.rpcUrl),
+        transport: fallback(l1RpcUrls.map(url => http(url))),
       })
     : undefined;
 

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

@@ -1,11 +1,11 @@
 import { CheatCodes, createPXEClient, makeFetch } from '@aztec/aztec.js';
-import { type LogFn } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 
-export async function advanceEpoch(l1RpcUrl: string, rpcUrl: string, log: LogFn) {
-  const pxe = createPXEClient(rpcUrl, makeFetch([], true));
+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(l1RpcUrl, { 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

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

package/src/cmds/l1/bridge_erc20.ts

@@ -1,14 +1,13 @@
-import { L1ToL2TokenPortalManager } from '@aztec/aztec.js';
-import { type AztecAddress, type EthAddress, type Fr } from '@aztec/circuits.js';
+import { type AztecAddress, type EthAddress, type Fr, L1ToL2TokenPortalManager } from '@aztec/aztec.js';
 import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
-import { type LogFn, type Logger } from '@aztec/foundation/log';
+import type { LogFn, Logger } from '@aztec/foundation/log';
 
 import { prettyPrintJSON } from '../../utils/commands.js';
 
 export async function bridgeERC20(
   amount: bigint,
   recipient: AztecAddress,
-  l1RpcUrl: string,
+  l1RpcUrls: string[],
   chainId: number,
   privateKey: string | undefined,
   mnemonic: string,
@@ -21,8 +20,8 @@ export async function bridgeERC20(
   debugLogger: Logger,
 ) {
   // Prepare L1 client
-  const chain = createEthereumChain(l1RpcUrl, chainId);
-  const { publicClient, walletClient } = createL1Clients(chain.rpcUrl, privateKey ?? mnemonic, chain.chainInfo);
+  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);

package/src/cmds/l1/create_l1_account.ts

@@ -1,4 +1,4 @@
-import { type LogFn } from '@aztec/foundation/log';
+import type { LogFn } from '@aztec/foundation/log';
 
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 

package/src/cmds/l1/deploy_l1_contracts.ts

@@ -1,16 +1,19 @@
+import { getInitialTestAccounts } from '@aztec/accounts/testing';
 import { getL1ContractsConfigEnvVars } from '@aztec/ethereum';
-import { type EthAddress } from '@aztec/foundation/eth-address';
-import { type LogFn, type Logger } from '@aztec/foundation/log';
+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(
-  rpcUrl: string,
+  rpcUrls: string[],
   chainId: number,
   privateKey: string | undefined,
   mnemonic: string,
   mnemonicIndex: number,
   salt: number | undefined,
+  testAccounts: boolean,
   json: boolean,
   initialValidators: EthAddress[],
   log: LogFn,
@@ -18,14 +21,19 @@ export async function deployL1Contracts(
 ) {
   const config = getL1ContractsConfigEnvVars();
 
+  const initialFundedAccounts = testAccounts ? await getInitialTestAccounts() : [];
+  const { genesisBlockHash, genesisArchiveRoot } = await getGenesisValues(initialFundedAccounts.map(a => a.address));
+
   const { l1ContractAddresses } = await deployAztecContracts(
-    rpcUrl,
+    rpcUrls,
     chainId,
     privateKey,
     mnemonic,
     mnemonicIndex,
     salt,
     initialValidators,
+    genesisArchiveRoot,
+    genesisBlockHash,
     config,
     debugLogger,
   );
@@ -50,6 +58,6 @@ export async function deployL1Contracts(
     log(`RewardDistributor Address: ${l1ContractAddresses.rewardDistributorAddress.toString()}`);
     log(`GovernanceProposer Address: ${l1ContractAddresses.governanceProposerAddress.toString()}`);
     log(`Governance Address: ${l1ContractAddresses.governanceAddress.toString()}`);
-    log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress.toString()}`);
+    log(`SlashFactory Address: ${l1ContractAddresses.slashFactoryAddress?.toString()}`);
   }
 }

package/src/cmds/l1/deploy_l1_verifier.ts

@@ -1,6 +1,6 @@
 import { createCompatibleClient } from '@aztec/aztec.js';
 import { createEthereumChain, createL1Clients, deployL1Contract } from '@aztec/ethereum';
-import { type LogFn, type Logger } from '@aztec/foundation/log';
+import type { LogFn, Logger } from '@aztec/foundation/log';
 import { HonkVerifierAbi, HonkVerifierBytecode } from '@aztec/l1-artifacts';
 
 import { InvalidOptionArgumentError } from 'commander';
@@ -8,7 +8,7 @@ import { type Hex, getContract } from 'viem';
 
 export async function deployUltraHonkVerifier(
   rollupAddress: Hex | undefined,
-  ethRpcUrl: string,
+  ethRpcUrls: string[],
   l1ChainId: string,
   privateKey: string | undefined,
   mnemonic: string,
@@ -23,9 +23,9 @@ export async function deployUltraHonkVerifier(
   }
 
   const { publicClient, walletClient } = createL1Clients(
-    ethRpcUrl,
+    ethRpcUrls,
     privateKey ?? mnemonic,
-    createEthereumChain(ethRpcUrl, l1ChainId).chainInfo,
+    createEthereumChain(ethRpcUrls, l1ChainId).chainInfo,
   );
 
   if (!rollupAddress && pxeRpcUrl) {
@@ -61,7 +61,7 @@ export async function deployUltraHonkVerifier(
 
 export async function deployMockVerifier(
   rollupAddress: Hex | undefined,
-  ethRpcUrl: string,
+  ethRpcUrls: string[],
   l1ChainId: string,
   privateKey: string | undefined,
   mnemonic: string,
@@ -70,9 +70,9 @@ export async function deployMockVerifier(
   debugLogger: Logger,
 ) {
   const { publicClient, walletClient } = createL1Clients(
-    ethRpcUrl,
+    ethRpcUrls,
     privateKey ?? mnemonic,
-    createEthereumChain(ethRpcUrl, l1ChainId).chainInfo,
+    createEthereumChain(ethRpcUrls, l1ChainId).chainInfo,
   );
   const { MockVerifierAbi, MockVerifierBytecode, RollupAbi } = await import('@aztec/l1-artifacts');
 

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

@@ -1,22 +1,25 @@
-import { type EthAddress } from '@aztec/circuits.js';
 import { createEthereumChain } from '@aztec/ethereum';
-import { type LogFn } from '@aztec/foundation/log';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { LogFn } from '@aztec/foundation/log';
 import { TestERC20Abi } from '@aztec/l1-artifacts';
 
-import { createPublicClient, getContract, http } from 'viem';
+import { createPublicClient, fallback, getContract, http } from 'viem';
 
 import { prettyPrintJSON } from '../../utils/commands.js';
 
 export async function getL1Balance(
   who: EthAddress,
   token: EthAddress | undefined,
-  l1RpcUrl: string,
+  l1RpcUrls: string[],
   chainId: number,
   json: boolean,
   log: LogFn,
 ) {
-  const chain = createEthereumChain(l1RpcUrl, chainId);
-  const publicClient = createPublicClient({ chain: chain.chainInfo, transport: http(chain.rpcUrl) });
+  const chain = createEthereumChain(l1RpcUrls, chainId);
+  const publicClient = createPublicClient({
+    chain: chain.chainInfo,
+    transport: fallback(l1RpcUrls.map(url => http(url))),
+  });
 
   let balance = 0n;
   if (token) {

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 });
+}