@aztec/bot 0.0.1-commit.03f7ef2 → 0.0.1-commit.04852196a

package/dest/utils.js

@@ -4,10 +4,10 @@
  * @param who - Address to get the balance for.
  * @returns - Private and public token balances as bigints.
  */ export async function getBalances(token, who, from) {
-    const privateBalance = await token.methods.balance_of_private(who).simulate({
+    const { result: privateBalance } = await token.methods.balance_of_private(who).simulate({
         from: from ?? who
     });
-    const publicBalance = await token.methods.balance_of_public(who).simulate({
+    const { result: publicBalance } = await token.methods.balance_of_public(who).simulate({
         from: from ?? who
     });
     return {
@@ -16,7 +16,7 @@
     };
 }
 export async function getPrivateBalance(token, who, from) {
-    const privateBalance = await token.methods.get_balance(who).simulate({
+    const { result: privateBalance } = await token.methods.get_balance(who).simulate({
         from: from ?? who
     });
     return privateBalance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/bot",
-  "version": "0.0.1-commit.03f7ef2",
+  "version": "0.0.1-commit.04852196a",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -54,20 +54,23 @@
     ]
   },
   "dependencies": {
-    "@aztec/accounts": "0.0.1-commit.03f7ef2",
-    "@aztec/aztec.js": "0.0.1-commit.03f7ef2",
-    "@aztec/entrypoints": "0.0.1-commit.03f7ef2",
-    "@aztec/ethereum": "0.0.1-commit.03f7ef2",
-    "@aztec/foundation": "0.0.1-commit.03f7ef2",
-    "@aztec/kv-store": "0.0.1-commit.03f7ef2",
-    "@aztec/noir-contracts.js": "0.0.1-commit.03f7ef2",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.03f7ef2",
-    "@aztec/protocol-contracts": "0.0.1-commit.03f7ef2",
-    "@aztec/stdlib": "0.0.1-commit.03f7ef2",
-    "@aztec/telemetry-client": "0.0.1-commit.03f7ef2",
-    "@aztec/test-wallet": "0.0.1-commit.03f7ef2",
+    "@aztec/accounts": "0.0.1-commit.04852196a",
+    "@aztec/aztec.js": "0.0.1-commit.04852196a",
+    "@aztec/entrypoints": "0.0.1-commit.04852196a",
+    "@aztec/ethereum": "0.0.1-commit.04852196a",
+    "@aztec/foundation": "0.0.1-commit.04852196a",
+    "@aztec/kv-store": "0.0.1-commit.04852196a",
+    "@aztec/l1-artifacts": "0.0.1-commit.04852196a",
+    "@aztec/noir-contracts.js": "0.0.1-commit.04852196a",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.04852196a",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.04852196a",
+    "@aztec/protocol-contracts": "0.0.1-commit.04852196a",
+    "@aztec/stdlib": "0.0.1-commit.04852196a",
+    "@aztec/telemetry-client": "0.0.1-commit.04852196a",
+    "@aztec/wallets": "0.0.1-commit.04852196a",
     "source-map-support": "^0.5.21",
     "tslib": "^2.4.0",
+    "viem": "npm:@aztec/viem@2.38.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -75,7 +78,7 @@
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
     "@types/source-map-support": "^0.5.10",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "ts-node": "^10.9.1",

package/src/amm_bot.ts

@@ -1,12 +1,12 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import { SentTx } from '@aztec/aztec.js/contracts';
+import { NO_WAIT } from '@aztec/aztec.js/contracts';
 import { Fr } from '@aztec/aztec.js/fields';
-import { TxReceipt } from '@aztec/aztec.js/tx';
+import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import type { AMMContract } from '@aztec/noir-contracts.js/AMM';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { BaseBot } from './base_bot.js';
 import type { BotConfig } from './config.js';
@@ -21,7 +21,7 @@ type Balances = { token0: bigint; token1: bigint };
 export class AmmBot extends BaseBot {
   protected constructor(
     node: AztecNode,
-    wallet: TestWallet,
+    wallet: EmbeddedWallet,
     defaultAccountAddress: AztecAddress,
     public readonly amm: AMMContract,
     public readonly token0: TokenContract,
@@ -33,7 +33,7 @@ export class AmmBot extends BaseBot {
 
   static async create(
     config: BotConfig,
-    wallet: TestWallet,
+    wallet: EmbeddedWallet,
     aztecNode: AztecNode,
     aztecNodeAdmin: AztecNodeAdmin | undefined,
     store: BotStore,
@@ -48,7 +48,7 @@ export class AmmBot extends BaseBot {
     return new AmmBot(aztecNode, wallet, defaultAccountAddress, amm, token0, token1, config);
   }
 
-  protected async createAndSendTx(logCtx: object): Promise<SentTx> {
+  protected async createAndSendTx(logCtx: object): Promise<TxHash> {
     const { feePaymentMethod } = this.config;
     const { wallet, amm, token0, token1 } = this;
 
@@ -71,12 +71,14 @@ export class AmmBot extends BaseBot {
         .getFunctionCall(),
     });
 
-    const amountOutMin = await amm.methods
-      .get_amount_out_for_exact_in(
-        await tokenIn.methods.balance_of_public(amm.address).simulate({ from: this.defaultAccountAddress }),
-        await tokenOut.methods.balance_of_public(amm.address).simulate({ from: this.defaultAccountAddress }),
-        amountIn,
-      )
+    const { result: tokenInBalance } = await tokenIn.methods
+      .balance_of_public(amm.address)
+      .simulate({ from: this.defaultAccountAddress });
+    const { result: tokenOutBalance } = await tokenOut.methods
+      .balance_of_public(amm.address)
+      .simulate({ from: this.defaultAccountAddress });
+    const { result: amountOutMin } = await amm.methods
+      .get_amount_out_for_exact_in(tokenInBalance, tokenOutBalance, amountIn)
       .simulate({ from: this.defaultAccountAddress });
 
     const swapExactTokensInteraction = amm.methods
@@ -89,7 +91,8 @@ export class AmmBot extends BaseBot {
 
     this.log.verbose(`Sending transaction`, logCtx);
     this.log.info(`Tx. Balances: ${jsonStringify(balances)}`, { ...logCtx, balances });
-    return swapExactTokensInteraction.send(opts);
+    const { txHash } = await swapExactTokensInteraction.send({ ...opts, wait: NO_WAIT });
+    return txHash;
   }
 
   protected override async onTxMined(receipt: TxReceipt, logCtx: object): Promise<void> {
@@ -110,15 +113,17 @@ export class AmmBot extends BaseBot {
   }
 
   private async getPublicBalanceFor(address: AztecAddress, from?: AztecAddress): Promise<Balances> {
-    return {
-      token0: await this.token0.methods.balance_of_public(address).simulate({ from: from ?? address }),
-      token1: await this.token1.methods.balance_of_public(address).simulate({ from: from ?? address }),
-    };
+    const { result: token0 } = await this.token0.methods.balance_of_public(address).simulate({ from: from ?? address });
+    const { result: token1 } = await this.token1.methods.balance_of_public(address).simulate({ from: from ?? address });
+    return { token0, token1 };
   }
   private async getPrivateBalanceFor(address: AztecAddress, from?: AztecAddress): Promise<Balances> {
-    return {
-      token0: await this.token0.methods.balance_of_private(address).simulate({ from: from ?? address }),
-      token1: await this.token1.methods.balance_of_private(address).simulate({ from: from ?? address }),
-    };
+    const { result: token0 } = await this.token0.methods
+      .balance_of_private(address)
+      .simulate({ from: from ?? address });
+    const { result: token1 } = await this.token1.methods
+      .balance_of_private(address)
+      .simulate({ from: from ?? address });
+    return { token0, token1 };
   }
 }

package/src/base_bot.ts

@@ -1,16 +1,11 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
-import {
-  BatchCall,
-  ContractFunctionInteraction,
-  type SendInteractionOptions,
-  SentTx,
-  waitForProven,
-} from '@aztec/aztec.js/contracts';
+import { BatchCall, ContractFunctionInteraction, type SendInteractionOptions } from '@aztec/aztec.js/contracts';
 import { createLogger } from '@aztec/aztec.js/log';
-import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
+import { waitForTx } from '@aztec/aztec.js/node';
+import { TxHash, TxReceipt, TxStatus } from '@aztec/aztec.js/tx';
 import { Gas } from '@aztec/stdlib/gas';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import type { BotConfig } from './config.js';
 
@@ -22,36 +17,27 @@ export abstract class BaseBot {
 
   protected constructor(
     public readonly node: AztecNode,
-    public readonly wallet: TestWallet,
+    public readonly wallet: EmbeddedWallet,
     public readonly defaultAccountAddress: AztecAddress,
     public config: BotConfig,
   ) {}
 
   public async run(): Promise<TxReceipt | TxHash> {
     this.attempts++;
-    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000) };
     const { followChain, txMinedWaitSeconds } = this.config;
+    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000), followChain, txMinedWaitSeconds };
 
     this.log.verbose(`Creating tx`, logCtx);
-    const tx = await this.createAndSendTx(logCtx);
-
-    const txHash = await tx.getTxHash();
+    const txHash = await this.createAndSendTx(logCtx);
 
     if (followChain === 'NONE') {
       this.log.info(`Transaction ${txHash.toString()} sent, not waiting for it to be mined`);
       return txHash;
     }
 
-    this.log.verbose(
-      `Awaiting tx ${txHash.toString()} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
-      logCtx,
-    );
-    const receipt = await tx.wait({
-      timeout: txMinedWaitSeconds,
-    });
-    if (followChain === 'PROVEN') {
-      await waitForProven(this.node, receipt, { provenTimeout: txMinedWaitSeconds });
-    }
+    const waitForStatus = TxStatus[followChain];
+    this.log.verbose(`Awaiting tx ${txHash.toString()} to be on the ${followChain} chain`, logCtx);
+    const receipt = await waitForTx(this.node, txHash, { timeout: txMinedWaitSeconds, waitForStatus });
     this.successes++;
     this.log.info(
       `Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`,
@@ -63,7 +49,7 @@ export abstract class BaseBot {
     return receipt;
   }
 
-  protected abstract createAndSendTx(logCtx: object): Promise<SentTx>;
+  protected abstract createAndSendTx(logCtx: object): Promise<TxHash>;
 
   protected onTxMined(_receipt: TxReceipt, _logCtx: object): Promise<void> {
     // no-op
@@ -73,9 +59,9 @@ export abstract class BaseBot {
   protected async getSendMethodOpts(
     interaction: ContractFunctionInteraction | BatchCall,
   ): Promise<SendInteractionOptions> {
-    const { l2GasLimit, daGasLimit, baseFeePadding } = this.config;
+    const { l2GasLimit, daGasLimit, minFeePadding } = this.config;
 
-    this.wallet.setBaseFeePadding(baseFeePadding);
+    this.wallet.setMinFeePadding(minFeePadding);
 
     let gasSettings;
     if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {

package/src/bot.ts

@@ -1,10 +1,11 @@
 import type { AztecAddress } from '@aztec/aztec.js/addresses';
-import { BatchCall, SentTx } from '@aztec/aztec.js/contracts';
+import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
 import { times } from '@aztec/foundation/collection';
 import type { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
-import type { TestWallet } from '@aztec/test-wallet/server';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
 import { BaseBot } from './base_bot.js';
 import type { BotConfig } from './config.js';
@@ -17,7 +18,7 @@ const TRANSFER_AMOUNT = 1;
 export class Bot extends BaseBot {
   protected constructor(
     node: AztecNode,
-    wallet: TestWallet,
+    wallet: EmbeddedWallet,
     defaultAccountAddress: AztecAddress,
     public readonly token: TokenContract | PrivateTokenContract,
     public readonly recipient: AztecAddress,
@@ -28,7 +29,7 @@ export class Bot extends BaseBot {
 
   static async create(
     config: BotConfig,
-    wallet: TestWallet,
+    wallet: EmbeddedWallet,
     aztecNode: AztecNode,
     aztecNodeAdmin: AztecNodeAdmin | undefined,
     store: BotStore,
@@ -48,7 +49,7 @@ export class Bot extends BaseBot {
     this.config = { ...this.config, ...config };
   }
 
-  protected async createAndSendTx(logCtx: object): Promise<SentTx> {
+  protected async createAndSendTx(logCtx: object): Promise<TxHash> {
     const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod } = this.config;
     const { token, recipient, wallet } = this;
 
@@ -75,14 +76,15 @@ export class Bot extends BaseBot {
     await batch.simulate({ from: this.defaultAccountAddress });
 
     this.log.verbose(`Sending transaction`, logCtx);
-    return batch.send(opts);
+    const { txHash } = await batch.send({ ...opts, wait: NO_WAIT });
+    return txHash;
   }
 
   public async getBalances() {
     if (isStandardTokenContract(this.token)) {
       return {
         sender: await getBalances(this.token, this.defaultAccountAddress),
-        recipient: await getBalances(this.token, this.recipient, this.defaultAccountAddress),
+        recipient: await getBalances(this.token, this.recipient),
       };
     } else {
       return {
@@ -91,7 +93,7 @@ export class Bot extends BaseBot {
           publicBalance: 0n,
         },
         recipient: {
-          privateBalance: await getPrivateBalance(this.token, this.recipient, this.defaultAccountAddress),
+          privateBalance: await getPrivateBalance(this.token, this.recipient),
           publicBalance: 0n,
         },
       };

package/src/config.ts

@@ -11,17 +11,20 @@ import {
   secretStringConfigHelper,
 } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
 import { schemas, zodFor } from '@aztec/stdlib/schemas';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
 import { z } from 'zod';
 
-const BotFollowChain = ['NONE', 'PENDING', 'PROVEN'] as const;
+const BotFollowChain = ['NONE', 'PROPOSED', 'CHECKPOINTED', 'PROVEN'] as const;
 type BotFollowChain = (typeof BotFollowChain)[number];
 
+const BotMode = ['transfer', 'amm', 'crosschain'] as const;
+type BotMode = (typeof BotMode)[number];
+
 export enum SupportedTokenContracts {
   TokenContract = 'TokenContract',
   PrivateTokenContract = 'PrivateTokenContract',
@@ -54,8 +57,8 @@ export type BotConfig = {
   publicTransfersPerTx: number;
   /** How to handle fee payments. */
   feePaymentMethod: 'fee_juice';
-  /** 'How much is the bot willing to overpay vs. the current base fee' */
-  baseFeePadding: number;
+  /** 'How much is the bot willing to overpay vs. the current min fee' */
+  minFeePadding: number;
   /** True to not automatically setup or start the bot on initialization. */
   noStart: boolean;
   /** How long to wait for a tx to be mined before reporting an error. */
@@ -76,8 +79,12 @@ export type BotConfig = {
   maxConsecutiveErrors: number;
   /** Stops the bot if service becomes unhealthy */
   stopWhenUnhealthy: boolean;
-  /** Deploy an AMM contract and do swaps instead of transfers */
-  ammTxs: boolean;
+  /** Bot mode: transfer, amm, or crosschain. */
+  botMode: BotMode;
+  /** Number of L2→L1 messages per tx (crosschain mode). */
+  l2ToL1MessagesPerTx: number;
+  /** Max L1→L2 messages to keep in-flight (crosschain mode). */
+  l1ToL2SeedCount: number;
 } & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'>;
 
 export const BotConfigSchema = zodFor<BotConfig>()(
@@ -96,7 +103,7 @@ export const BotConfigSchema = zodFor<BotConfig>()(
       privateTransfersPerTx: z.number().int().nonnegative(),
       publicTransfersPerTx: z.number().int().nonnegative(),
       feePaymentMethod: z.literal('fee_juice'),
-      baseFeePadding: z.number().int().nonnegative(),
+      minFeePadding: z.number().int().nonnegative(),
       noStart: z.boolean(),
       txMinedWaitSeconds: z.number(),
       followChain: z.enum(BotFollowChain),
@@ -107,7 +114,9 @@ export const BotConfigSchema = zodFor<BotConfig>()(
       contract: z.nativeEnum(SupportedTokenContracts),
       maxConsecutiveErrors: z.number().int().nonnegative(),
       stopWhenUnhealthy: z.boolean(),
-      ammTxs: z.boolean().default(false),
+      botMode: z.enum(BotMode).default('transfer'),
+      l2ToL1MessagesPerTx: z.number().int().nonnegative().default(1),
+      l1ToL2SeedCount: z.number().int().nonnegative().default(1),
       dataDirectory: z.string().optional(),
       dataStoreMapSizeKb: z.number().optional(),
     })
@@ -121,7 +130,6 @@ export const BotConfigSchema = zodFor<BotConfig>()(
       l1Mnemonic: undefined,
       l1PrivateKey: undefined,
       senderPrivateKey: undefined,
-      dataDirectory: undefined,
       dataStoreMapSizeKb: 1_024 * 1_024,
       ...config,
     })),
@@ -193,8 +201,8 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     parseEnv: val => (val as 'fee_juice') || undefined,
     defaultValue: 'fee_juice',
   },
-  baseFeePadding: {
-    env: 'BOT_BASE_FEE_PADDING',
+  minFeePadding: {
+    env: 'BOT_MIN_FEE_PADDING',
     description: 'How much is the bot willing to overpay vs. the current base fee',
     ...numberConfigHelper(3),
   },
@@ -213,10 +221,14 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Which chain the bot follows',
     defaultValue: 'NONE',
     parseEnv(val) {
-      if (!(BotFollowChain as readonly string[]).includes(val.toUpperCase())) {
+      const upper = val.toUpperCase();
+      if (upper === 'PENDING') {
+        return 'CHECKPOINTED';
+      }
+      if (!(BotFollowChain as readonly string[]).includes(upper)) {
         throw new Error(`Invalid value for BOT_FOLLOW_CHAIN: ${val}`);
       }
-      return val as BotFollowChain;
+      return upper as BotFollowChain;
     },
   },
   maxPendingTxs: {
@@ -264,10 +276,26 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Stops the bot if service becomes unhealthy',
     ...booleanConfigHelper(false),
   },
-  ammTxs: {
-    env: 'BOT_AMM_TXS',
-    description: 'Deploy an AMM and send swaps to it',
-    ...booleanConfigHelper(false),
+  botMode: {
+    env: 'BOT_MODE',
+    description: 'Bot mode: transfer, amm, or crosschain',
+    defaultValue: 'transfer' as BotMode,
+    parseEnv(val: string) {
+      if (!(BotMode as readonly string[]).includes(val)) {
+        throw new Error(`Invalid value for BOT_MODE: ${val}`);
+      }
+      return val as BotMode;
+    },
+  },
+  l2ToL1MessagesPerTx: {
+    env: 'BOT_L2_TO_L1_MESSAGES_PER_TX',
+    description: 'Number of L2→L1 messages per tx (crosschain mode)',
+    ...numberConfigHelper(1),
+  },
+  l1ToL2SeedCount: {
+    env: 'BOT_L1_TO_L2_SEED_COUNT',
+    description: 'Max L1→L2 messages to keep in-flight (crosschain mode)',
+    ...numberConfigHelper(1),
   },
   ...pickConfigMappings(dataConfigMappings, ['dataStoreMapSizeKb', 'dataDirectory']),
 };

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