@aztec/bot 0.0.1-commit.fce3e4f → 0.0.1-commit.ffe5b04ea

package/src/cross_chain_bot.ts

@@ -0,0 +1,203 @@
+/**
+ * CrossChainBot exercises L2->L1 and L1->L2 messaging.
+ *
+ *   createAndSendTx                          onTxMined
+ *   ──────────────────────────────────────   ──────────────────────────────
+ *
+ *   1. SEED (fire-and-forget)                3. VERIFY L2->L1
+ *      if store has fewer pending messages       Query getTxEffect, confirm
+ *      than seedCount and no seed is              the expected L2->L1 messages
+ *      in-flight:                                appeared in tx effects.
+ *        * kick off L1 inbox tx
+ *        * store msg on completion
+ *
+ *   2. BUILD & SEND BATCH
+ *      Always:
+ *        N x create_l2_to_l1_message
+ *            (random content, fixed
+ *             L1 recipient)
+ *      If a ready L1->L2 msg exists:
+ *        1 x consume_message_from_
+ *            arbitrary_sender_public
+ *        delete consumed msg from store
+ *      Send batch tx (no wait)
+ *
+ */
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
+import { isL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { TestContract } from '@aztec/noir-test-contracts.js/Test';
+import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
+
+import { BaseBot } from './base_bot.js';
+import type { BotConfig } from './config.js';
+import { BotFactory } from './factory.js';
+import { seedL1ToL2Message } from './l1_to_l2_seeding.js';
+import type { BotStore, PendingL1ToL2Message } from './store/index.js';
+
+/** Stale message threshold: messages older than this are removed. */
+const STALE_MESSAGE_THRESHOLD_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+/** Bot that exercises both L2→L1 and L1→L2 cross-chain messaging. */
+export class CrossChainBot extends BaseBot {
+  private l2ToL1Sent = 0;
+  private l1ToL2Consumed = 0;
+  private pendingSeedPromise: Promise<void> | undefined;
+
+  protected constructor(
+    node: AztecNode,
+    wallet: EmbeddedWallet,
+    defaultAccountAddress: AztecAddress,
+    private readonly contract: TestContract,
+    private readonly l1Client: ExtendedViemWalletClient,
+    private readonly l1Recipient: EthAddress,
+    private readonly inboxAddress: EthAddress,
+    private readonly rollupVersion: bigint,
+    private readonly store: BotStore,
+    config: BotConfig,
+  ) {
+    super(node, wallet, defaultAccountAddress, config);
+  }
+
+  static async create(
+    config: BotConfig,
+    wallet: EmbeddedWallet,
+    aztecNode: AztecNode,
+    aztecNodeAdmin: AztecNodeAdmin | undefined,
+    store: BotStore,
+  ): Promise<CrossChainBot> {
+    if (config.followChain === 'NONE') {
+      throw new Error(`CrossChainBot requires followChain to be set (got NONE)`);
+    }
+    const factory = new BotFactory(config, wallet, store, aztecNode, aztecNodeAdmin);
+    const { defaultAccountAddress, contract, l1Client, rollupVersion } = await factory.setupCrossChain();
+    const l1Recipient = EthAddress.fromString(l1Client.account!.address);
+    const { l1ContractAddresses } = await aztecNode.getNodeInfo();
+    const inboxAddress = EthAddress.fromString(l1ContractAddresses.inboxAddress.toString());
+    return new CrossChainBot(
+      aztecNode,
+      wallet,
+      defaultAccountAddress,
+      contract,
+      l1Client,
+      l1Recipient,
+      inboxAddress,
+      rollupVersion,
+      store,
+      config,
+    );
+  }
+
+  protected async createAndSendTx(logCtx: object): Promise<TxHash> {
+    const pendingMessages = await this.store.getUnconsumedL1ToL2Messages();
+
+    // Send an L1→L2 message if we're below the threshold and not already seeding one
+    if (pendingMessages.length < this.config.l1ToL2SeedCount && !this.pendingSeedPromise) {
+      this.pendingSeedPromise = this.seedNewL1ToL2Message()
+        .catch(err => this.log.warn(`Failed to seed L1→L2 message: ${err}`, logCtx))
+        .finally(() => {
+          this.pendingSeedPromise = undefined;
+        });
+    }
+
+    // Build batch: always L2→L1, optionally consume L1→L2
+    const calls = [];
+
+    // L2→L1: create messages with random content
+    for (let i = 0; i < this.config.l2ToL1MessagesPerTx; i++) {
+      calls.push(
+        this.contract.methods.create_l2_to_l1_message_arbitrary_recipient_public(Fr.random(), this.l1Recipient),
+      );
+    }
+
+    // L1→L2: consume oldest ready message if available
+    const readyMsg = await this.getReadyL1ToL2Message(pendingMessages);
+    if (readyMsg) {
+      calls.push(
+        this.contract.methods.consume_message_from_arbitrary_sender_public(
+          Fr.fromHexString(readyMsg.content),
+          Fr.fromHexString(readyMsg.secret),
+          EthAddress.fromString(readyMsg.sender),
+          new Fr(BigInt(readyMsg.globalLeafIndex)),
+        ),
+      );
+      // Delete consumed message immediately so it works with FOLLOW_CHAIN=NONE
+      await this.store.deleteL1ToL2Message(readyMsg.msgHash);
+      this.l1ToL2Consumed++;
+    } else {
+      this.log.warn(`No ready L1→L2 message to consume`, {
+        ...logCtx,
+        pendingCount: pendingMessages.length,
+      });
+    }
+
+    const batch = new BatchCall(this.wallet, calls);
+    const opts = await this.getSendMethodOpts(batch);
+
+    this.log.verbose(`Sending cross-chain batch with ${calls.length} calls`, logCtx);
+    const { txHash } = await batch.send({ ...opts, wait: NO_WAIT });
+    return txHash;
+  }
+
+  protected override async onTxMined(receipt: TxReceipt, logCtx: object): Promise<void> {
+    // Verify L2→L1 messages appeared in this tx's effects
+    const indexed = await this.node.getTxEffect(receipt.txHash);
+    if (indexed) {
+      const l2ToL1Msgs = indexed.data.l2ToL1Msgs.filter(m => !m.isZero());
+      if (l2ToL1Msgs.length >= this.config.l2ToL1MessagesPerTx) {
+        this.l2ToL1Sent += l2ToL1Msgs.length;
+      } else {
+        this.log.error(`Expected ${this.config.l2ToL1MessagesPerTx} L2→L1 messages but found ${l2ToL1Msgs.length}`, {
+          ...logCtx,
+          blockNumber: receipt.blockNumber,
+          txHash: receipt.txHash.toString(),
+        });
+      }
+    }
+
+    const pendingCount = (await this.store.getUnconsumedL1ToL2Messages()).length;
+    this.log.info(`CrossChainBot txs mined`, {
+      ...logCtx,
+      l2ToL1Sent: this.l2ToL1Sent,
+      l1ToL2Consumed: this.l1ToL2Consumed,
+      l1ToL2Pending: pendingCount,
+    });
+  }
+
+  /** Finds the oldest pending message that is ready for consumption. */
+  private async getReadyL1ToL2Message(
+    pendingMessages: PendingL1ToL2Message[],
+  ): Promise<PendingL1ToL2Message | undefined> {
+    const now = Date.now();
+    for (const msg of pendingMessages) {
+      const ready = await isL1ToL2MessageReady(this.node, Fr.fromHexString(msg.msgHash));
+      if (ready) {
+        return msg;
+      }
+
+      // Time-based stale detection: if the message is old and still not ready, remove it
+      if (now - msg.timestamp > STALE_MESSAGE_THRESHOLD_MS) {
+        await this.store.deleteL1ToL2Message(msg.msgHash);
+        this.log.warn(`Removed stale L1→L2 message ${msg.msgHash}`);
+      }
+    }
+    return undefined;
+  }
+
+  /** Seeds a new L1→L2 message on L1 and stores it. */
+  private async seedNewL1ToL2Message(): Promise<void> {
+    await seedL1ToL2Message(
+      this.l1Client,
+      this.inboxAddress,
+      this.contract.address,
+      this.rollupVersion,
+      this.store,
+      this.log,
+    );
+  }
+}

package/src/factory.ts

@@ -1,4 +1,3 @@
-import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
 import { getInitialTestAccountsData } from '@aztec/accounts/testing';
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
@@ -7,24 +6,34 @@ import {
   ContractFunctionInteraction,
   type DeployMethod,
   type DeployOptions,
+  NO_WAIT,
 } from '@aztec/aztec.js/contracts';
-import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
 import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
+import { deriveKeys } from '@aztec/aztec.js/keys';
 import { createLogger } from '@aztec/aztec.js/log';
 import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
-import { createEthereumChain, createExtendedL1Client } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Timer } from '@aztec/foundation/timer';
 import { AMMContract } from '@aztec/noir-contracts.js/AMM';
 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 type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { TestWallet } from '@aztec/test-wallet/server';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { type BotConfig, SupportedTokenContracts } from './config.js';
+import { seedL1ToL2Message } from './l1_to_l2_seeding.js';
 import type { BotStore } from './store/index.js';
 import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
 
@@ -36,32 +45,36 @@ export class BotFactory {
 
   constructor(
     private readonly config: BotConfig,
-    private readonly wallet: TestWallet,
+    private readonly wallet: EmbeddedWallet,
     private readonly store: BotStore,
     private readonly aztecNode: AztecNode,
     private readonly aztecNodeAdmin?: AztecNodeAdmin,
-  ) {}
+  ) {
+    // Set fee padding on the wallet so that all transactions during setup
+    // (token deploy, minting, etc.) use the configured padding, not the default.
+    this.wallet.setMinFeePadding(config.minFeePadding);
+  }
 
   /**
    * Initializes a new bot by setting up the sender account, registering the recipient,
    * deploying the token contract, and minting tokens if necessary.
    */
   public async setup(): Promise<{
-    wallet: TestWallet;
+    wallet: EmbeddedWallet;
     defaultAccountAddress: AztecAddress;
     token: TokenContract | PrivateTokenContract;
     node: AztecNode;
     recipient: AztecAddress;
   }> {
-    const recipient = (await this.wallet.createAccount()).address;
     const defaultAccountAddress = await this.setupAccount();
+    const recipient = (await this.wallet.createSchnorrAccount(Fr.random(), Fr.random())).address;
     const token = await this.setupToken(defaultAccountAddress);
     await this.mintTokens(token, defaultAccountAddress);
     return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
   }
 
   public async setupAmm(): Promise<{
-    wallet: TestWallet;
+    wallet: EmbeddedWallet;
     defaultAccountAddress: AztecAddress;
     amm: AMMContract;
     token0: TokenContract;
@@ -91,6 +104,89 @@ export class BotFactory {
     return { wallet: this.wallet, defaultAccountAddress, amm, token0, token1, node: this.aztecNode };
   }
 
+  /**
+   * Initializes the cross-chain bot by deploying TestContract, creating an L1 client,
+   * seeding initial L1→L2 messages, and waiting for the first to be ready.
+   */
+  public async setupCrossChain(): Promise<{
+    wallet: EmbeddedWallet;
+    defaultAccountAddress: AztecAddress;
+    contract: TestContract;
+    node: AztecNode;
+    l1Client: ExtendedViemWalletClient;
+    rollupVersion: bigint;
+  }> {
+    const defaultAccountAddress = await this.setupAccount();
+
+    // Create L1 client (same pattern as bridgeL1FeeJuice)
+    const l1RpcUrls = this.config.l1RpcUrls;
+    if (!l1RpcUrls?.length) {
+      throw new Error('L1 RPC URLs required for cross-chain bot');
+    }
+    const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
+    if (!mnemonicOrPrivateKey) {
+      throw new Error('L1 mnemonic or private key required for cross-chain bot');
+    }
+    const { l1ChainId, l1ContractAddresses } = await this.aztecNode.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+    const l1Client = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+
+    // Fetch Rollup version (needed for Inbox L2Actor struct)
+    const rollupContract = new RollupContract(l1Client, l1ContractAddresses.rollupAddress.toString());
+    const rollupVersion = await rollupContract.getVersion();
+
+    // Deploy TestContract
+    const contract = await this.setupTestContract(defaultAccountAddress);
+
+    // Recover any pending messages from store (clean up stale ones first)
+    await this.store.cleanupOldPendingMessages();
+    const pendingMessages = await this.store.getUnconsumedL1ToL2Messages();
+
+    // Seed initial L1→L2 messages if pipeline is empty
+    const seedCount = Math.max(0, this.config.l1ToL2SeedCount - pendingMessages.length);
+    for (let i = 0; i < seedCount; i++) {
+      await seedL1ToL2Message(
+        l1Client,
+        EthAddress.fromString(l1ContractAddresses.inboxAddress.toString()),
+        contract.address,
+        rollupVersion,
+        this.store,
+        this.log,
+      );
+    }
+
+    // Block until at least one message is ready
+    const allMessages = await this.store.getUnconsumedL1ToL2Messages();
+    if (allMessages.length > 0) {
+      this.log.info(`Waiting for first L1→L2 message to be ready...`);
+      const firstMsg = allMessages[0];
+      await waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(firstMsg.msgHash), {
+        timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+      });
+      this.log.info(`First L1→L2 message is ready`);
+    }
+
+    return {
+      wallet: this.wallet,
+      defaultAccountAddress,
+      contract,
+      node: this.aztecNode,
+      l1Client,
+      rollupVersion,
+    };
+  }
+
+  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 instance = await this.registerOrDeployContract('TestContract', deploy, deployOpts);
+    return TestContract.at(instance.address, this.wallet);
+  }
+
   /**
    * Checks if the sender account contract is initialized, and initializes it if necessary.
    * @returns The sender wallet.
@@ -109,14 +205,9 @@ export class BotFactory {
   private async setupAccountWithPrivateKey(secret: Fr) {
     const salt = this.config.senderSalt ?? Fr.ONE;
     const signingKey = deriveSigningKey(secret);
-    const accountData = {
-      secret,
-      salt,
-      contract: new SchnorrAccountContract(signingKey!),
-    };
-    const accountManager = await this.wallet.createAccount(accountData);
-    const isInit = (await this.wallet.getContractMetadata(accountManager.address)).isContractInitialized;
-    if (isInit) {
+    const accountManager = await this.wallet.createSchnorrAccount(secret, salt, signingKey);
+    const metadata = await this.wallet.getContractMetadata(accountManager.address);
+    if (metadata.isContractInitialized) {
       this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
       const timer = new Timer();
       const address = accountManager.address;
@@ -131,12 +222,18 @@ export class BotFactory {
 
       const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
       const deployMethod = await accountManager.getDeployMethod();
-      const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.config.baseFeePadding);
+      const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
       const gasSettings = GasSettings.default({ maxFeesPerGas });
-      const sentTx = deployMethod.send({ from: AztecAddress.ZERO, fee: { gasSettings, paymentMethod } });
-      const txHash = await sentTx.getTxHash();
-      this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
-      await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
+
+      await this.withNoMinTxsPerBlock(async () => {
+        const { txHash } = await deployMethod.send({
+          from: AztecAddress.ZERO,
+          fee: { gasSettings, paymentMethod },
+          wait: NO_WAIT,
+        });
+        this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
+        return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+      });
       this.log.info(`Account deployed at ${address}`);
 
       // Clean up the consumed bridge claim
@@ -148,12 +245,11 @@ export class BotFactory {
 
   private async setupTestAccount() {
     const [initialAccountData] = await getInitialTestAccountsData();
-    const accountData = {
-      secret: initialAccountData.secret,
-      salt: initialAccountData.salt,
-      contract: new SchnorrAccountContract(initialAccountData.signingKey),
-    };
-    const accountManager = await this.wallet.createAccount(accountData);
+    const accountManager = await this.wallet.createSchnorrAccount(
+      initialAccountData.secret,
+      initialAccountData.salt,
+      initialAccountData.signingKey,
+    );
     return accountManager.address;
   }
 
@@ -164,33 +260,51 @@ export class BotFactory {
    */
   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,
     };
+    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);
     } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
-      deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender);
+      // 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);
       deployOpts.skipInstancePublication = true;
       deployOpts.skipClassPublication = true;
       deployOpts.skipInitialization = false;
+
+      // Register the contract with the secret key before deployment
+      tokenInstance = await deploy.getInstance(deployOpts);
+      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.
+      deployOpts.additionalScopes = [tokenInstance.address];
     } else {
       throw new Error(`Unsupported token contract type: ${this.config.contract}`);
     }
 
-    const address = (await deploy.getInstance(deployOpts)).address;
-    if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
+    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`);
-      return deploy.register();
+      await deploy.register();
     } else {
       this.log.info(`Deploying token contract at ${address.toString()}`);
-      const sentTx = deploy.send(deployOpts);
-      const txHash = await sentTx.getTxHash();
+      const { txHash } = await deploy.send({ ...deployOpts, wait: NO_WAIT });
       this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
-      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
+      await this.withNoMinTxsPerBlock(async () => {
+        await waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+        return token;
+      });
     }
+    return token;
   }
 
   /**
@@ -198,7 +312,7 @@ export class BotFactory {
    * @param wallet - Wallet to deploy the token contract from.
    * @returns The TokenContract instance.
    */
-  private setupTokenContract(
+  private async setupTokenContract(
     deployer: AztecAddress,
     contractAddressSalt: Fr,
     name: string,
@@ -207,7 +321,8 @@ export class BotFactory {
   ): Promise<TokenContract> {
     const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
     const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
-    return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    return TokenContract.at(instance.address, this.wallet);
   }
 
   private async setupAmmContract(
@@ -219,12 +334,14 @@ export class BotFactory {
   ): Promise<AMMContract> {
     const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
     const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
-    const amm = await this.registerOrDeployContract('AMM', deploy, deployOpts);
+    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 minterTx = lpToken.methods.set_minter(amm.address, true).send({ from: deployer });
-    this.log.info(`Set LP token minter to AMM txHash=${(await minterTx.getTxHash()).toString()}`);
-    await minterTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    const { receipt: minterReceipt } = await lpToken.methods
+      .set_minter(amm.address, true)
+      .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`);
 
     return amm;
@@ -240,9 +357,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();
@@ -283,23 +409,22 @@ export class BotFactory {
         .getFunctionCall(),
     });
 
-    const mintTx = new BatchCall(this.wallet, [
+    const { receipt: mintReceipt } = await new BatchCall(this.wallet, [
       token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
       token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
-    ]).send({ from: liquidityProvider });
+    ]).send({ from: liquidityProvider, wait: { timeout: this.config.txMinedWaitSeconds } });
 
-    this.log.info(`Sent mint tx: ${(await mintTx.getTxHash()).toString()}`);
-    await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
 
-    const addLiquidityTx = amm.methods
+    const { receipt: addLiquidityReceipt } = await amm.methods
       .add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce)
       .send({
         from: liquidityProvider,
         authWitnesses: [token0Authwit, token1Authwit],
+        wait: { timeout: this.config.txMinedWaitSeconds },
       });
 
-    this.log.info(`Sent tx to add liquidity to the AMM: ${(await addLiquidityTx.getTxHash()).toString()}`);
-    await addLiquidityTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Sent tx to add liquidity to the AMM: ${addLiquidityReceipt.txHash.toString()}`);
     this.log.info(`Liquidity added`);
 
     const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
@@ -312,18 +437,22 @@ export class BotFactory {
     name: string,
     deploy: DeployMethod<T>,
     deployOpts: DeployOptions,
-  ): Promise<T> {
-    const address = (await deploy.getInstance(deployOpts)).address;
-    if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
+  ): Promise<ContractInstanceWithAddress> {
+    const instance = await deploy.getInstance(deployOpts);
+    const address = instance.address;
+    const metadata = await this.wallet.getContractMetadata(address);
+    if (metadata.isContractPublished) {
       this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
-      return deploy.register();
+      await deploy.register();
     } else {
       this.log.info(`Deploying contract ${name} at ${address.toString()}`);
-      const sentTx = deploy.send(deployOpts);
-      const txHash = await sentTx.getTxHash();
-      this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
-      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
+      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 });
+      });
     }
+    return instance;
   }
 
   /**
@@ -359,10 +488,18 @@ export class BotFactory {
       this.log.info(`Skipping minting as ${minter.toString()} has enough tokens`);
       return;
     }
-    const sentTx = new BatchCall(token.wallet, calls).send({ from: minter });
-    const txHash = await sentTx.getTxHash();
-    this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
-    await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
+
+    // PrivateToken's mint accesses contract-level private storage vars (admin, total_supply).
+    const additionalScopes = isStandardToken ? undefined : [token.address];
+    await this.withNoMinTxsPerBlock(async () => {
+      const { txHash } = await new BatchCall(token.wallet, calls).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 });
+    });
   }
 
   /**
@@ -382,7 +519,6 @@ export class BotFactory {
         await this.withNoMinTxsPerBlock(() =>
           waitForL1ToL2MessageReady(this.aztecNode, messageHash, {
             timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
-            forPublicConsumption: false,
           }),
         );
         return existingClaim.claim;
@@ -421,7 +557,6 @@ export class BotFactory {
     await this.withNoMinTxsPerBlock(() =>
       waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
-        forPublicConsumption: false,
       }),
     );
 

package/src/index.ts

@@ -1,5 +1,6 @@
 export { Bot } from './bot.js';
 export { AmmBot } from './amm_bot.js';
+export { CrossChainBot } from './cross_chain_bot.js';
 export { BotRunner } from './runner.js';
 export { BotStore } from './store/bot_store.js';
 export {