@aztec/bot 0.0.1-commit.181e2d196 → 0.0.1-commit.189eedb3

package/src/factory.ts

@@ -1,4 +1,5 @@
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { NO_FROM } from '@aztec/aztec.js/account';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
   BatchCall,
@@ -15,6 +16,8 @@ import { deriveKeys } from '@aztec/aztec.js/keys';
 import { createLogger } from '@aztec/aztec.js/log';
 import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
 import { waitForTx } from '@aztec/aztec.js/node';
+import { getFeeJuiceBalance } from '@aztec/aztec.js/utils';
+import { ContractInitializationStatus } from '@aztec/aztec.js/wallet';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { RollupContract } from '@aztec/ethereum/contracts';
@@ -27,7 +30,7 @@ import { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TestContract } from '@aztec/noir-test-contracts.js/Test';
 import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
-import { GasSettings } from '@aztec/stdlib/gas';
+import { GasFees, GasSettings, ManaUsageEstimate } from '@aztec/stdlib/gas';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 import { EmbeddedWallet } from '@aztec/wallets/embedded';
@@ -39,6 +42,8 @@ import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils
 
 const MINT_BALANCE = 1e12;
 const MIN_BALANCE = 1e3;
+const FEE_JUICE_TOP_UP_THRESHOLD = 100n * 10n ** 18n;
+const FEE_JUICE_TOP_UP_TARGET = 10_000n * 10n ** 18n;
 
 export class BotFactory {
   private log = createLogger('bot');
@@ -68,7 +73,8 @@ export class BotFactory {
   }> {
     const defaultAccountAddress = await this.setupAccount();
     const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random())).address;
-    const token = await this.setupToken(defaultAccountAddress);
+    const token = await this.setupTokenWithOptionalEarlyRefuel(defaultAccountAddress);
+    await this.ensureFeeJuiceBalance(defaultAccountAddress, token);
     await this.mintTokens(token, defaultAccountAddress);
     return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
   }
@@ -82,7 +88,13 @@ export class BotFactory {
     node: AztecNode;
   }> {
     const defaultAccountAddress = await this.setupAccount();
-    const token0 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken0', 'BOT0');
+    const token0 = await this.setupTokenContractWithOptionalEarlyRefuel(
+      defaultAccountAddress,
+      this.config.tokenSalt,
+      'BotToken0',
+      'BOT0',
+    );
+    await this.ensureFeeJuiceBalance(defaultAccountAddress, token0);
     const token1 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken1', 'BOT1');
     const liquidityToken = await this.setupTokenContract(
       defaultAccountAddress,
@@ -162,11 +174,6 @@ export class BotFactory {
       const firstMsg = allMessages[0];
       await waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(firstMsg.msgHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
-        // Use forPublicConsumption: false so we wait until the message is in the current world
-        // state. With true, it returns one block early which causes gas estimation simulation to
-        // fail since it runs against the current state.
-        // See https://linear.app/aztec-labs/issue/A-548 for details.
-        forPublicConsumption: false,
       });
       this.log.info(`First L1→L2 message is ready`);
     }
@@ -182,12 +189,8 @@ export class BotFactory {
   }
 
   private async setupTestContract(deployer: AztecAddress): Promise<TestContract> {
-    const deployOpts: DeployOptions = {
-      from: deployer,
-      contractAddressSalt: this.config.tokenSalt,
-      universalDeploy: true,
-    };
-    const deploy = TestContract.deploy(this.wallet);
+    const deployOpts: DeployOptions = { from: deployer };
+    const deploy = TestContract.deploy(this.wallet, { salt: this.config.tokenSalt, universalDeploy: true });
     const instance = await this.registerOrDeployContract('TestContract', deploy, deployOpts);
     return TestContract.at(instance.address, this.wallet);
   }
@@ -212,7 +215,7 @@ export class BotFactory {
     const signingKey = deriveSigningKey(secret);
     const accountManager = await this.wallet.createSchnorrAccount(secret, salt, signingKey);
     const metadata = await this.wallet.getContractMetadata(accountManager.address);
-    if (metadata.isContractInitialized) {
+    if (metadata.initializationStatus === ContractInitializationStatus.INITIALIZED) {
       this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
       const timer = new Timer();
       const address = accountManager.address;
@@ -227,13 +230,11 @@ export class BotFactory {
 
       const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
       const deployMethod = await accountManager.getDeployMethod();
-      const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
-      const gasSettings = GasSettings.default({ maxFeesPerGas });
 
       await this.withNoMinTxsPerBlock(async () => {
-        const txHash = await deployMethod.send({
-          from: AztecAddress.ZERO,
-          fee: { gasSettings, paymentMethod },
+        const { txHash } = await deployMethod.send({
+          from: NO_FROM,
+          fee: { paymentMethod },
           wait: NO_WAIT,
         });
         this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
@@ -258,35 +259,95 @@ export class BotFactory {
     return accountManager.address;
   }
 
+  /**
+   * Setup token and refuel first: if the token already exists (restart scenario),
+   * run ensureFeeJuiceBalance before any step that might need fee juice. When deploying,
+   * use a bridge claim if balance is below threshold.
+   */
+  private async setupTokenWithOptionalEarlyRefuel(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
+    const token = await this.getTokenInstance(sender);
+    const address = token.address;
+    const metadata = await this.wallet.getContractMetadata(address);
+    if (metadata.isContractPublished) {
+      this.log.info(`Token at ${address.toString()} already deployed, refueling before setup`);
+      await this.ensureFeeJuiceBalance(sender, token);
+    }
+    return this.setupToken(sender);
+  }
+
+  /**
+   * Setup token0 for AMM with refuel-first behaviour when token already exists.
+   */
+  private async setupTokenContractWithOptionalEarlyRefuel(
+    deployer: AztecAddress,
+    salt: Fr,
+    name: string,
+    ticker: string,
+    decimals = 18,
+  ): Promise<TokenContract> {
+    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals, { salt, universalDeploy: true });
+    const instance = await deploy.getInstance();
+    const metadata = await this.wallet.getContractMetadata(instance.address);
+    if (metadata.isContractPublished) {
+      this.log.info(`Token ${name} at ${instance.address.toString()} already deployed, refueling before setup`);
+      const token = TokenContract.at(instance.address, this.wallet);
+      await this.ensureFeeJuiceBalance(deployer, token);
+    }
+    return this.setupTokenContract(deployer, salt, name, ticker, decimals);
+  }
+
+  private async getTokenInstance(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
+    const salt = this.config.tokenSalt;
+    if (this.config.contract === SupportedTokenContracts.TokenContract) {
+      const deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18, { salt, universalDeploy: true });
+      const instance = await deploy.getInstance();
+      return TokenContract.at(instance.address, this.wallet);
+    }
+    if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
+      const tokenSecretKey = Fr.random();
+      const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
+      const deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender, {
+        salt,
+        universalDeploy: true,
+        publicKeys: tokenPublicKeys,
+      });
+      const instance = await deploy.getInstance();
+      return PrivateTokenContract.at(instance.address, this.wallet);
+    }
+    throw new Error(`Unsupported token contract type: ${this.config.contract}`);
+  }
+
   /**
    * Checks if the token contract is deployed and deploys it if necessary.
-   * @param wallet - Wallet to deploy the token contract from.
-   * @returns The TokenContract instance.
+   * Uses a bridge claim for deploy when balance is below threshold to avoid failing before refuel.
+   * @param sender - Aztec address to deploy the token contract from.
+   * @param existingToken - Optional token instance when called from setupTokenWithOptionalEarlyRefuel.
+   * @returns The TokenContract or PrivateTokenContract instance.
    */
   private async setupToken(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
     let deploy: DeployMethod<TokenContract | PrivateTokenContract>;
-    let tokenInstance: ContractInstanceWithAddress | undefined;
-    const deployOpts: DeployOptions = {
-      from: sender,
-      contractAddressSalt: this.config.tokenSalt,
-      universalDeploy: true,
-    };
+    const salt = this.config.tokenSalt;
+    const deployOpts: DeployOptions = { from: sender };
     let token: TokenContract | PrivateTokenContract;
     if (this.config.contract === SupportedTokenContracts.TokenContract) {
-      deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
-      tokenInstance = await deploy.getInstance(deployOpts);
-      token = TokenContract.at(tokenInstance.address, this.wallet);
+      deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18, { salt, universalDeploy: true });
+      const instance = await deploy.getInstance();
+      token = TokenContract.at(instance.address, this.wallet);
     } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
       // Generate keys for the contract since PrivateToken uses SinglePrivateMutable which requires keys
       const tokenSecretKey = Fr.random();
       const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
-      deploy = PrivateTokenContract.deployWithPublicKeys(tokenPublicKeys, this.wallet, MINT_BALANCE, sender);
+      deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender, {
+        salt,
+        universalDeploy: true,
+        publicKeys: tokenPublicKeys,
+      });
       deployOpts.skipInstancePublication = true;
       deployOpts.skipClassPublication = true;
       deployOpts.skipInitialization = false;
 
       // Register the contract with the secret key before deployment
-      tokenInstance = await deploy.getInstance(deployOpts);
+      const tokenInstance = await deploy.getInstance();
       token = PrivateTokenContract.at(tokenInstance.address, this.wallet);
       await this.wallet.registerContract(tokenInstance, PrivateTokenContract.artifact, tokenSecretKey);
       // The contract constructor initializes private storage vars that need the contract's own nullifier key.
@@ -295,20 +356,7 @@ export class BotFactory {
       throw new Error(`Unsupported token contract type: ${this.config.contract}`);
     }
 
-    const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
-    const metadata = await this.wallet.getContractMetadata(address);
-    if (metadata.isContractPublished) {
-      this.log.info(`Token at ${address.toString()} already deployed`);
-      await deploy.register();
-    } else {
-      this.log.info(`Deploying token contract at ${address.toString()}`);
-      const txHash = await deploy.send({ ...deployOpts, wait: NO_WAIT });
-      this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
-      await this.withNoMinTxsPerBlock(async () => {
-        await waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
-        return token;
-      });
-    }
+    await this.registerOrDeployContract('token', deploy, deployOpts);
     return token;
   }
 
@@ -319,33 +367,38 @@ export class BotFactory {
    */
   private async setupTokenContract(
     deployer: AztecAddress,
-    contractAddressSalt: Fr,
+    salt: Fr,
     name: string,
     ticker: string,
     decimals = 18,
   ): Promise<TokenContract> {
-    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
-    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
+    const deployOpts: DeployOptions = { from: deployer };
+    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals, { salt, universalDeploy: true });
     const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
     return TokenContract.at(instance.address, this.wallet);
   }
 
   private async setupAmmContract(
     deployer: AztecAddress,
-    contractAddressSalt: Fr,
+    salt: Fr,
     token0: TokenContract,
     token1: TokenContract,
     lpToken: TokenContract,
   ): Promise<AMMContract> {
-    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
-    const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
+    const deployOpts: DeployOptions = { from: deployer };
+    const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address, {
+      salt,
+      universalDeploy: true,
+    });
     const instance = await this.registerOrDeployContract('AMM', deploy, deployOpts);
     const amm = AMMContract.at(instance.address, this.wallet);
 
     this.log.info(`AMM deployed at ${amm.address}`);
-    const minterReceipt = await lpToken.methods
-      .set_minter(amm.address, true)
-      .send({ from: deployer, wait: { timeout: this.config.txMinedWaitSeconds } });
+    const setMinterInteraction = lpToken.methods.set_minter(amm.address, true);
+    const { receipt: minterReceipt } = await setMinterInteraction.send({
+      from: deployer,
+      wait: { timeout: this.config.txMinedWaitSeconds },
+    });
     this.log.info(`Set LP token minter to AMM txHash=${minterReceipt.txHash.toString()}`);
     this.log.info(`Liquidity token initialized`);
 
@@ -362,9 +415,18 @@ export class BotFactory {
   ): Promise<void> {
     const getPrivateBalances = () =>
       Promise.all([
-        token0.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
-        token1.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
-        lpToken.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
+        token0.methods
+          .balance_of_private(liquidityProvider)
+          .simulate({ from: liquidityProvider })
+          .then(r => r.result),
+        token1.methods
+          .balance_of_private(liquidityProvider)
+          .simulate({ from: liquidityProvider })
+          .then(r => r.result),
+        lpToken.methods
+          .balance_of_private(liquidityProvider)
+          .simulate({ from: liquidityProvider })
+          .then(r => r.result),
       ]);
 
     const authwitNonce = Fr.random();
@@ -405,20 +467,29 @@ export class BotFactory {
         .getFunctionCall(),
     });
 
-    const mintReceipt = await new BatchCall(this.wallet, [
+    const mintBatch = new BatchCall(this.wallet, [
       token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
       token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
-    ]).send({ from: liquidityProvider, wait: { timeout: this.config.txMinedWaitSeconds } });
+    ]);
+    const { receipt: mintReceipt } = await mintBatch.send({
+      from: liquidityProvider,
+      wait: { timeout: this.config.txMinedWaitSeconds },
+    });
 
     this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
 
-    const addLiquidityReceipt = await amm.methods
-      .add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce)
-      .send({
-        from: liquidityProvider,
-        authWitnesses: [token0Authwit, token1Authwit],
-        wait: { timeout: this.config.txMinedWaitSeconds },
-      });
+    const addLiquidityInteraction = amm.methods.add_liquidity(
+      amount0Max,
+      amount1Max,
+      amount0Min,
+      amount1Min,
+      authwitNonce,
+    );
+    const { receipt: addLiquidityReceipt } = await addLiquidityInteraction.send({
+      from: liquidityProvider,
+      authWitnesses: [token0Authwit, token1Authwit],
+      wait: { timeout: this.config.txMinedWaitSeconds },
+    });
 
     this.log.info(`Sent tx to add liquidity to the AMM: ${addLiquidityReceipt.txHash.toString()}`);
     this.log.info(`Liquidity added`);
@@ -434,19 +505,49 @@ export class BotFactory {
     deploy: DeployMethod<T>,
     deployOpts: DeployOptions,
   ): Promise<ContractInstanceWithAddress> {
-    const instance = await deploy.getInstance(deployOpts);
+    const instance = await deploy.getInstance();
     const address = instance.address;
     const metadata = await this.wallet.getContractMetadata(address);
     if (metadata.isContractPublished) {
       this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
       await deploy.register();
     } else {
-      this.log.info(`Deploying contract ${name} at ${address.toString()}`);
-      await this.withNoMinTxsPerBlock(async () => {
-        const txHash = await deploy.send({ ...deployOpts, wait: NO_WAIT });
-        this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
-        return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
-      });
+      const sender = deployOpts.from === NO_FROM ? undefined : deployOpts.from;
+      const balance = sender ? await getFeeJuiceBalance(sender, this.aztecNode) : 0n;
+      const useClaim =
+        sender &&
+        balance < FEE_JUICE_TOP_UP_THRESHOLD &&
+        this.config.feePaymentMethod === 'fee_juice' &&
+        !!this.config.l1RpcUrls?.length;
+      const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
+
+      if (useClaim && mnemonicOrPrivateKey) {
+        const claim = await this.getOrCreateBridgeClaim(sender!);
+        const paymentMethod = new FeeJuicePaymentMethodWithClaim(sender!, claim);
+        const { estimatedGas } = await deploy.simulate({ ...deployOpts, fee: { estimateGas: true, paymentMethod } });
+        const maxFeesPerGas = (await this.getMinFees()).mul(1 + this.config.minFeePadding);
+        const gasSettings = GasSettings.from({
+          ...estimatedGas!,
+          maxFeesPerGas,
+          maxPriorityFeesPerGas: GasFees.empty(),
+        });
+        await this.withNoMinTxsPerBlock(async () => {
+          const { txHash } = await deploy.send({ ...deployOpts, fee: { gasSettings, paymentMethod }, wait: NO_WAIT });
+          this.log.info(
+            `Sent contract ${name} deploy tx ${txHash.toString()} (using bridge claim, balance was ${balance})`,
+          );
+          return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+        });
+        await this.store.deleteBridgeClaim(sender!);
+      } else {
+        const { estimatedGas } = await deploy.simulate({ ...deployOpts, fee: { estimateGas: true } });
+        this.log.info(`Deploying contract ${name} at ${address.toString()}`, { estimatedGas });
+        await this.withNoMinTxsPerBlock(async () => {
+          const { txHash } = await deploy.send({ ...deployOpts, fee: { gasSettings: estimatedGas }, wait: NO_WAIT });
+          this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
+          return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+        });
+      }
     }
     return instance;
   }
@@ -455,6 +556,66 @@ export class BotFactory {
    * Mints private and public tokens for the sender if their balance is below the minimum.
    * @param token - Token contract.
    */
+  /**
+   * Ensures the account has sufficient fee juice by bridging from L1 if balance is below threshold.
+   * Bridges repeatedly until balance reaches the target (10k FJ).
+   * Used on startup/restart to top up when the account has run out after previous runs.
+   */
+  private async ensureFeeJuiceBalance(
+    account: AztecAddress,
+    token: TokenContract | PrivateTokenContract,
+  ): Promise<void> {
+    const { feePaymentMethod, l1RpcUrls } = this.config;
+    if (feePaymentMethod !== 'fee_juice' || !l1RpcUrls?.length) {
+      return;
+    }
+    const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
+    if (!mnemonicOrPrivateKey) {
+      return;
+    }
+
+    let balance = await getFeeJuiceBalance(account, this.aztecNode);
+    if (balance >= FEE_JUICE_TOP_UP_THRESHOLD) {
+      this.log.info(`Fee juice balance ${balance} above threshold ${FEE_JUICE_TOP_UP_THRESHOLD}, skipping top-up`);
+      return;
+    }
+
+    this.log.info(
+      `Fee juice balance ${balance} below threshold ${FEE_JUICE_TOP_UP_THRESHOLD}, bridging from L1 until ${FEE_JUICE_TOP_UP_TARGET}`,
+    );
+    const maxFeesPerGas = (await this.getMinFees()).mul(1 + this.config.minFeePadding);
+    const minimalInteraction = isStandardTokenContract(token)
+      ? token.methods.transfer_in_public(account, account, 0n, 0)
+      : token.methods.transfer(0n, account, account);
+
+    while (balance < FEE_JUICE_TOP_UP_TARGET) {
+      const claim = await this.bridgeL1FeeJuice(account);
+      const paymentMethod = new FeeJuicePaymentMethodWithClaim(account, claim);
+      const { estimatedGas } = await minimalInteraction.simulate({
+        from: account,
+        fee: { estimateGas: true, paymentMethod },
+      });
+      const gasSettings = GasSettings.from({
+        ...estimatedGas!,
+        maxFeesPerGas,
+        maxPriorityFeesPerGas: GasFees.empty(),
+      });
+
+      await this.withNoMinTxsPerBlock(async () => {
+        const { txHash } = await minimalInteraction.send({
+          from: account,
+          fee: { gasSettings, paymentMethod },
+          wait: NO_WAIT,
+        });
+        this.log.info(`Sent fee juice top-up tx ${txHash.toString()}`);
+        return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+      });
+      balance = await getFeeJuiceBalance(account, this.aztecNode);
+      this.log.info(`Fee juice balance after top-up: ${balance}`);
+    }
+    this.log.info(`Fee juice top-up complete for ${account.toString()}`);
+  }
+
   private async mintTokens(token: TokenContract | PrivateTokenContract, minter: AztecAddress) {
     const isStandardToken = isStandardTokenContract(token);
     let privateBalance = 0n;
@@ -487,8 +648,13 @@ export class BotFactory {
 
     // PrivateToken's mint accesses contract-level private storage vars (admin, total_supply).
     const additionalScopes = isStandardToken ? undefined : [token.address];
+    const mintBatch = new BatchCall(token.wallet, calls);
     await this.withNoMinTxsPerBlock(async () => {
-      const txHash = await new BatchCall(token.wallet, calls).send({ from: minter, additionalScopes, wait: NO_WAIT });
+      const { txHash } = await mintBatch.send({
+        from: minter,
+        additionalScopes,
+        wait: NO_WAIT,
+      });
       this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
       return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
     });
@@ -511,7 +677,6 @@ export class BotFactory {
         await this.withNoMinTxsPerBlock(() =>
           waitForL1ToL2MessageReady(this.aztecNode, messageHash, {
             timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
-            forPublicConsumption: false,
           }),
         );
         return existingClaim.claim;
@@ -550,7 +715,6 @@ export class BotFactory {
     await this.withNoMinTxsPerBlock(() =>
       waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
-        forPublicConsumption: false,
       }),
     );
 
@@ -559,6 +723,19 @@ export class BotFactory {
     return claim as L2AmountClaim;
   }
 
+  /** Returns worst-case min fees across predicted slots, with fallback to current min fees. */
+  private async getMinFees(): Promise<GasFees> {
+    try {
+      const predicted = await this.aztecNode.getPredictedMinFees(ManaUsageEstimate.Limit);
+      if (predicted.length === 0) {
+        return this.aztecNode.getCurrentMinFees();
+      }
+      return predicted.reduce((worst, fees) => (fees.feePerL2Gas > worst.feePerL2Gas ? fees : worst));
+    } catch {
+      return this.aztecNode.getCurrentMinFees();
+    }
+  }
+
   private async withNoMinTxsPerBlock<T>(fn: () => Promise<T>): Promise<T> {
     if (!this.aztecNodeAdmin || !this.config.flushSetupTransactions) {
       this.log.verbose(`No node admin client or flushing not requested (not setting minTxsPerBlock to 0)`);

package/src/interface.ts

@@ -22,11 +22,11 @@ export interface BotRunnerApi {
 }
 
 export const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi> = {
-  start: z.function().args().returns(z.void()),
-  stop: z.function().args().returns(z.void()),
-  run: z.function().args().returns(z.void()),
-  setup: z.function().args().returns(z.void()),
-  getInfo: z.function().args().returns(BotInfoSchema),
-  getConfig: z.function().args().returns(BotConfigSchema),
-  update: z.function().args(BotConfigSchema).returns(z.void()),
+  start: z.function({ input: z.tuple([]), output: z.void() }),
+  stop: z.function({ input: z.tuple([]), output: z.void() }),
+  run: z.function({ input: z.tuple([]), output: z.void() }),
+  setup: z.function({ input: z.tuple([]), output: z.void() }),
+  getInfo: z.function({ input: z.tuple([]), output: BotInfoSchema }),
+  getConfig: z.function({ input: z.tuple([]), output: BotConfigSchema }),
+  update: z.function({ input: z.tuple([BotConfigSchema]), output: z.void() }),
 };

package/src/utils.ts

@@ -15,8 +15,8 @@ export async function getBalances(
   who: AztecAddress,
   from?: AztecAddress,
 ): Promise<{ privateBalance: bigint; publicBalance: bigint }> {
-  const privateBalance = await token.methods.balance_of_private(who).simulate({ from: from ?? who });
-  const publicBalance = await token.methods.balance_of_public(who).simulate({ from: from ?? who });
+  const { result: privateBalance } = await token.methods.balance_of_private(who).simulate({ from: from ?? who });
+  const { result: publicBalance } = await token.methods.balance_of_public(who).simulate({ from: from ?? who });
   return { privateBalance, publicBalance };
 }
 
@@ -25,7 +25,7 @@ export async function getPrivateBalance(
   who: AztecAddress,
   from?: AztecAddress,
 ): Promise<bigint> {
-  const privateBalance = await token.methods.get_balance(who).simulate({ from: from ?? who });
+  const { result: privateBalance } = await token.methods.get_balance(who).simulate({ from: from ?? who });
   return privateBalance;
 }