@aztec-labs/bot 6.0.0-nightly.20260829

package/src/l1_to_l2_seeding.ts

@@ -0,0 +1,79 @@
+import { InboxAbi } from '@aztec/l1-artifacts';
+
+import { generateClaimSecret } from '@aztec-labs/aztec.js/ethereum';
+import type { ExtendedViemWalletClient } from '@aztec-labs/ethereum/types';
+import { compactArray } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Logger } from '@aztec-labs/foundation/log';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { decodeEventLog, getContract } from 'viem';
+
+import type { BotStore, PendingL1ToL2Message } from './store/index.js';
+
+/** Sends an L1→L2 message via the Inbox contract and stores it. */
+export async function seedL1ToL2Message(
+  l1Client: ExtendedViemWalletClient,
+  inboxAddress: EthAddress,
+  l2Recipient: AztecAddress,
+  rollupVersion: bigint,
+  store: BotStore,
+  log: Logger,
+): Promise<PendingL1ToL2Message> {
+  log.info('Seeding L1→L2 message');
+  const [secret, secretHash] = await generateClaimSecret(log);
+  const content = Fr.random();
+
+  const inbox = getContract({
+    address: inboxAddress.toString(),
+    abi: InboxAbi,
+    client: l1Client,
+  });
+
+  const txHash = await inbox.write.sendL2Message(
+    [{ actor: l2Recipient.toString(), version: rollupVersion }, content.toString(), secretHash.toString()],
+    { gas: 1_000_000n },
+  );
+  log.info(`L1→L2 message sent in tx ${txHash}`);
+
+  const txReceipt = await l1Client.waitForTransactionReceipt({ hash: txHash });
+  if (txReceipt.status !== 'success') {
+    throw new Error(`L1→L2 message tx failed: ${txHash}`);
+  }
+
+  // Extract MessageSent event
+  const messageSentLogs = compactArray(
+    txReceipt.logs
+      .filter(l => l.address.toLowerCase() === inboxAddress.toString().toLowerCase())
+      .map(l => {
+        try {
+          return decodeEventLog({ abi: InboxAbi, eventName: 'MessageSent', data: l.data, topics: l.topics });
+        } catch {
+          return undefined;
+        }
+      }),
+  );
+
+  if (messageSentLogs.length !== 1) {
+    throw new Error(`Expected 1 MessageSent event, got ${messageSentLogs.length}`);
+  }
+
+  const event = messageSentLogs[0];
+
+  const msgHash = event.args.hash;
+  const globalLeafIndex = event.args.message.index;
+
+  const msg: PendingL1ToL2Message = {
+    content: content.toString(),
+    secret: secret.toString(),
+    secretHash: secretHash.toString(),
+    msgHash,
+    sender: l1Client.account!.address,
+    globalLeafIndex: globalLeafIndex.toString(),
+    timestamp: Date.now(),
+  };
+
+  await store.savePendingL1ToL2Message(msg);
+  log.info(`Seeded L1→L2 message msgHash=${msg.msgHash}`);
+  return msg;
+}

package/src/rpc.ts

@@ -0,0 +1,8 @@
+import type { ApiHandler } from '@aztec-labs/foundation/json-rpc/server';
+
+import { BotRunnerApiSchema } from './interface.js';
+import type { BotRunner } from './runner.js';
+
+export function getBotRunnerApiHandler(botRunner: BotRunner): ApiHandler {
+  return [botRunner, BotRunnerApiSchema, botRunner.isHealthy.bind(botRunner)];
+}

package/src/runner.ts

@@ -0,0 +1,220 @@
+import { createLogger } from '@aztec-labs/aztec.js/log';
+import type { AztecNode } from '@aztec-labs/aztec.js/node';
+import { omit } from '@aztec-labs/foundation/collection';
+import { RunningPromise } from '@aztec-labs/foundation/running-promise';
+import type { BlockTag } from '@aztec-labs/stdlib/block';
+import type { AztecNodeAdmin } from '@aztec-labs/stdlib/interfaces/client';
+import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec-labs/telemetry-client';
+import type { EmbeddedWallet } from '@aztec-labs/wallets/embedded';
+
+import { AmmBot } from './amm_bot.js';
+import type { BaseBot } from './base_bot.js';
+import { Bot } from './bot.js';
+import type { BotConfig } from './config.js';
+import { CrossChainBot } from './cross_chain_bot.js';
+import type { BotInfo, BotRunnerApi } from './interface.js';
+import { BotStore } from './store/index.js';
+
+export class BotRunner implements BotRunnerApi, Traceable {
+  private log = createLogger('bot');
+  private bot?: Promise<BaseBot>;
+  private runningPromise: RunningPromise;
+  private consecutiveErrors = 0;
+  private healthy = true;
+
+  public readonly tracer: Tracer;
+
+  public constructor(
+    private config: BotConfig,
+    private readonly wallet: EmbeddedWallet,
+    private readonly aztecNode: AztecNode,
+    private readonly telemetry: TelemetryClient,
+    private readonly aztecNodeAdmin: AztecNodeAdmin | undefined,
+    private readonly store: BotStore,
+    private readonly syncChainTip?: BlockTag,
+  ) {
+    this.tracer = telemetry.getTracer('Bot');
+
+    this.runningPromise = new RunningPromise(() => this.#work(), this.log, config.txIntervalSeconds * 1000);
+  }
+
+  /** Initializes the bot if needed. Blocks until the bot setup is finished. */
+  public async setup() {
+    if (!this.bot) {
+      await this.doSetup();
+    }
+  }
+
+  @trackSpan('Bot.setup')
+  private async doSetup() {
+    this.log.verbose(`Setting up bot`);
+    await this.#createBot();
+    this.log.info(`Bot set up completed`);
+  }
+
+  /**
+   * Initializes the bot if needed and starts sending txs at regular intervals.
+   * Blocks until the bot setup is finished.
+   */
+  public async start() {
+    await this.setup();
+    if (!this.runningPromise.isRunning()) {
+      this.log.info(`Starting bot with interval of ${this.config.txIntervalSeconds}s`);
+      this.runningPromise.start();
+    }
+  }
+
+  /**
+   * Stops sending txs. Returns once all ongoing txs are finished.
+   */
+  public async stop() {
+    if (this.runningPromise.isRunning()) {
+      this.log.verbose(`Stopping bot`);
+      await this.runningPromise.stop();
+    }
+    await this.store.close();
+    this.log.info(`Stopped bot`);
+  }
+
+  public isHealthy() {
+    return this.runningPromise.isRunning() && this.healthy;
+  }
+
+  /** Returns whether the bot is running. */
+  public isRunning() {
+    return this.runningPromise.isRunning();
+  }
+
+  /**
+   * Updates the bot config and recreates the bot. Will stop and restart the bot automatically if it was
+   * running when this method was called. Blocks until the new bot is set up.
+   */
+  public async update(config: BotConfig) {
+    this.log.verbose(`Updating bot config`);
+    const wasRunning = this.isRunning();
+    if (wasRunning) {
+      await this.stop();
+    }
+    this.config = { ...this.config, ...config };
+    this.runningPromise.setPollingIntervalMS(this.config.txIntervalSeconds * 1000);
+    await this.#createBot();
+    this.log.info(`Bot config updated`);
+    if (wasRunning) {
+      await this.start();
+    }
+  }
+
+  /**
+   * Triggers a single iteration of the bot. Requires the bot to be initialized.
+   * Blocks until the run is finished.
+   */
+  public async run() {
+    if (!this.bot) {
+      this.log.error(`Trying to run with uninitialized bot`);
+      throw new Error(`Bot is not initialized`);
+    }
+
+    let bot;
+    try {
+      bot = await this.bot;
+    } catch (err) {
+      this.log.error(`Error awaiting bot set up: ${err}`);
+      throw err;
+    }
+
+    try {
+      await bot.run();
+      this.consecutiveErrors = 0;
+    } catch (err) {
+      this.consecutiveErrors += 1;
+      this.log.error(`Error running bot consecutiveCount=${this.consecutiveErrors}: ${err}`);
+      throw err;
+    }
+  }
+
+  /** Returns the current configuration for the bot. */
+  public getConfig() {
+    const redacted = omit(this.config, 'l1Mnemonic', 'l1PrivateKey', 'senderPrivateKey');
+    return Promise.resolve(redacted as BotConfig);
+  }
+
+  /** Returns the bot sender address. */
+  public async getInfo(): Promise<BotInfo> {
+    if (!this.bot) {
+      throw new Error(`Bot is not initialized`);
+    }
+    const botAddress = await this.bot.then(b => b.defaultAccountAddress);
+    return { botAddress };
+  }
+
+  async #createBot() {
+    try {
+      switch (this.config.botMode) {
+        case 'crosschain':
+          this.bot = CrossChainBot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
+          break;
+        case 'amm':
+          this.bot = AmmBot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
+          break;
+        case 'transfer':
+          this.bot = Bot.create(
+            this.config,
+            this.wallet,
+            this.aztecNode,
+            this.aztecNodeAdmin,
+            this.store,
+            this.syncChainTip,
+          );
+          break;
+        default: {
+          const _exhaustive: never = this.config.botMode;
+          throw new Error(`Unsupported bot mode: [${_exhaustive}]`);
+        }
+      }
+      await this.bot;
+    } catch (err) {
+      this.log.error(`Error setting up bot: ${err}`);
+      throw err;
+    }
+  }
+
+  @trackSpan('Bot.work')
+  async #work() {
+    if (this.config.maxPendingTxs > 0) {
+      const pendingTxCount = await this.aztecNode.getPendingTxCount();
+      if (pendingTxCount >= this.config.maxPendingTxs) {
+        this.log.verbose(`Not sending bot tx since node has ${pendingTxCount} pending txs`);
+        return;
+      }
+    }
+
+    try {
+      await this.run();
+    } catch {
+      // Already logged in run()
+      if (this.config.maxConsecutiveErrors > 0 && this.consecutiveErrors >= this.config.maxConsecutiveErrors) {
+        this.log.error(`Too many errors bot is unhealthy`);
+        this.healthy = false;
+      }
+    }
+
+    if (!this.healthy && this.config.stopWhenUnhealthy) {
+      this.log.fatal(`Stopping bot due to errors`);
+      process.exit(1); // workaround docker not restarting the container if its unhealthy. We have to exit instead
+    }
+  }
+}

package/src/store/bot_store.ts

@@ -0,0 +1,196 @@
+import { AztecAddress } from '@aztec-labs/aztec.js/addresses';
+import type { L2AmountClaim } from '@aztec-labs/aztec.js/ethereum';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec-labs/foundation/log';
+import { DateProvider } from '@aztec-labs/foundation/timer';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec-labs/kv-store';
+
+export interface BridgeClaimData {
+  claim: L2AmountClaim;
+  timestamp: number;
+  recipient: string;
+}
+
+export interface PendingL1ToL2Message {
+  /** Random content field sent in the message. */
+  content: string;
+  /** Secret for consuming the message. */
+  secret: string;
+  /** Hash of the secret. */
+  secretHash: string;
+  /** Hash of the L1→L2 message. */
+  msgHash: string;
+  /** L1 sender address (hex). */
+  sender: string;
+  /** Global leaf index in the L1→L2 message tree. */
+  globalLeafIndex: string;
+  /** Timestamp when the message was seeded. */
+  timestamp: number;
+}
+
+/**
+ * Simple data store for the bot to persist L1 bridge claims.
+ */
+export class BotStore {
+  public static readonly SCHEMA_VERSION = 1;
+  private readonly bridgeClaims: AztecAsyncMap<string, string>;
+  private readonly pendingL1ToL2: AztecAsyncMap<string, string>;
+
+  constructor(
+    private readonly store: AztecAsyncKVStore,
+    private readonly log: Logger = createLogger('bot:store'),
+    private readonly dateProvider: DateProvider = new DateProvider(),
+  ) {
+    this.bridgeClaims = store.openMap<string, string>('bridge_claims');
+    this.pendingL1ToL2 = store.openMap<string, string>('pending_l1_to_l2');
+  }
+
+  /**
+   * Saves a bridge claim for a recipient.
+   */
+  public async saveBridgeClaim(recipient: AztecAddress, claim: L2AmountClaim): Promise<void> {
+    // Convert Fr fields and BigInts to strings for JSON serialization
+    const serializableClaim = {
+      claimAmount: claim.claimAmount.toString(),
+      claimSecret: claim.claimSecret.toString(),
+      claimSecretHash: claim.claimSecretHash.toString(),
+      messageHash: claim.messageHash,
+      messageLeafIndex: claim.messageLeafIndex.toString(),
+    };
+
+    const data = {
+      claim: serializableClaim,
+      timestamp: this.dateProvider.now(),
+      recipient: recipient.toString(),
+    };
+
+    await this.bridgeClaims.set(recipient.toString(), JSON.stringify(data));
+    this.log.info(`Saved bridge claim for ${recipient.toString()}`);
+  }
+
+  /**
+   * Gets a bridge claim for a recipient if it exists.
+   */
+  public async getBridgeClaim(recipient: AztecAddress): Promise<BridgeClaimData | undefined> {
+    const data = await this.bridgeClaims.getAsync(recipient.toString());
+    if (!data) {
+      return undefined;
+    }
+
+    const parsed = JSON.parse(data);
+
+    // Reconstruct L2AmountClaim from serialized data
+    const claim: L2AmountClaim = {
+      claimAmount: BigInt(parsed.claim.claimAmount),
+      claimSecret: Fr.fromString(parsed.claim.claimSecret),
+      claimSecretHash: Fr.fromString(parsed.claim.claimSecretHash),
+      messageHash: parsed.claim.messageHash,
+      messageLeafIndex: BigInt(parsed.claim.messageLeafIndex),
+    };
+
+    return {
+      claim,
+      timestamp: parsed.timestamp,
+      recipient: parsed.recipient,
+    };
+  }
+
+  /**
+   * Deletes a bridge claim for a recipient.
+   */
+  public async deleteBridgeClaim(recipient: AztecAddress): Promise<void> {
+    await this.bridgeClaims.delete(recipient.toString());
+    this.log.info(`Deleted bridge claim for ${recipient.toString()}`);
+  }
+
+  /**
+   * Gets all stored bridge claims.
+   */
+  public async getAllBridgeClaims(): Promise<BridgeClaimData[]> {
+    const claims: BridgeClaimData[] = [];
+    const entries = this.bridgeClaims.entriesAsync();
+
+    for await (const [_, data] of entries) {
+      const parsed = JSON.parse(data);
+
+      // Reconstruct L2AmountClaim from serialized data
+      const claim: L2AmountClaim = {
+        claimAmount: BigInt(parsed.claim.claimAmount),
+        claimSecret: Fr.fromString(parsed.claim.claimSecret),
+        claimSecretHash: Fr.fromString(parsed.claim.claimSecretHash),
+        messageHash: parsed.claim.messageHash,
+        messageLeafIndex: BigInt(parsed.claim.messageLeafIndex),
+      };
+
+      claims.push({
+        claim,
+        timestamp: parsed.timestamp,
+        recipient: parsed.recipient,
+      });
+    }
+
+    return claims;
+  }
+
+  /**
+   * Cleans up old bridge claims (older than 24 hours).
+   */
+  public async cleanupOldClaims(maxAgeMs: number = 24 * 60 * 60 * 1000): Promise<number> {
+    const now = this.dateProvider.now();
+    let cleanedCount = 0;
+    const entries = this.bridgeClaims.entriesAsync();
+
+    for await (const [key, data] of entries) {
+      const parsed = JSON.parse(data);
+      if (now - parsed.timestamp > maxAgeMs) {
+        await this.bridgeClaims.delete(key);
+        cleanedCount++;
+        this.log.info(`Cleaned up old bridge claim for ${parsed.recipient}`);
+      }
+    }
+
+    return cleanedCount;
+  }
+
+  /** Saves a pending L1→L2 message keyed by msgHash. */
+  public async savePendingL1ToL2Message(msg: PendingL1ToL2Message): Promise<void> {
+    await this.pendingL1ToL2.set(msg.msgHash, JSON.stringify(msg));
+    this.log.info(`Saved pending L1→L2 message ${msg.msgHash}`);
+  }
+
+  /** Returns all unconsumed pending L1→L2 messages. */
+  public async getUnconsumedL1ToL2Messages(): Promise<PendingL1ToL2Message[]> {
+    const messages: PendingL1ToL2Message[] = [];
+    for await (const [_, data] of this.pendingL1ToL2.entriesAsync()) {
+      messages.push(JSON.parse(data));
+    }
+    return messages;
+  }
+
+  /** Deletes a consumed L1→L2 message from the store. */
+  public async deleteL1ToL2Message(msgHash: string): Promise<void> {
+    await this.pendingL1ToL2.delete(msgHash);
+    this.log.info(`Deleted consumed L1→L2 message ${msgHash}`);
+  }
+
+  /** Cleans up pending L1→L2 messages older than maxAgeMs. */
+  public async cleanupOldPendingMessages(maxAgeMs: number = 24 * 60 * 60 * 1000): Promise<number> {
+    const now = this.dateProvider.now();
+    let cleanedCount = 0;
+    for await (const [key, data] of this.pendingL1ToL2.entriesAsync()) {
+      const parsed = JSON.parse(data);
+      if (now - parsed.timestamp > maxAgeMs) {
+        await this.pendingL1ToL2.delete(key);
+        cleanedCount++;
+        this.log.info(`Cleaned up old pending L1→L2 message ${key}`);
+      }
+    }
+    return cleanedCount;
+  }
+
+  /** Closes the store. */
+  public async close(): Promise<void> {
+    await this.store.close();
+    this.log.info('Closed bot data store');
+  }
+}

package/src/store/index.ts

@@ -0,0 +1 @@
+export { BotStore, type BridgeClaimData, type PendingL1ToL2Message } from './bot_store.js';

package/src/utils.ts

@@ -0,0 +1,38 @@
+import { ContractBase } from '@aztec-labs/aztec.js/contracts';
+import type { AMMContract } from '@aztec-labs/noir-contracts.js/AMM';
+import type { PrivateTokenContract } from '@aztec-labs/noir-contracts.js/PrivateToken';
+import type { TokenContract } from '@aztec-labs/noir-contracts.js/Token';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+
+/**
+ * Gets the private and public balance of the given token for the given address.
+ * @param token - Token contract.
+ * @param who - Address to get the balance for.
+ * @returns - Private and public token balances as bigints.
+ */
+export async function getBalances(
+  token: TokenContract,
+  who: AztecAddress,
+  from?: AztecAddress,
+): Promise<{ privateBalance: bigint; publicBalance: bigint }> {
+  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 };
+}
+
+export async function getPrivateBalance(
+  token: PrivateTokenContract,
+  who: AztecAddress,
+  from?: AztecAddress,
+): Promise<bigint> {
+  const { result: privateBalance } = await token.methods.get_balance(who).simulate({ from: from ?? who });
+  return privateBalance;
+}
+
+export function isStandardTokenContract(token: ContractBase): token is TokenContract {
+  return 'mint_to_public' in token.methods;
+}
+
+export function isAMMContract(contract: ContractBase): contract is AMMContract {
+  return 'add_liquidity' in contract.methods;
+}