@aztec/bot 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/index.ts

@@ -1,5 +1,8 @@
 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 {
   type BotConfig,
   getBotConfigFromEnv,
@@ -7,5 +10,5 @@ export {
   botConfigMappings,
   SupportedTokenContracts,
 } from './config.js';
-export { createBotRunnerRpcServer, getBotRunnerApiHandler } from './rpc.js';
+export { getBotRunnerApiHandler } from './rpc.js';
 export * from './interface.js';

package/src/interface.ts

@@ -1,15 +1,23 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 
 import { z } from 'zod';
 
 import { type BotConfig, BotConfigSchema } from './config.js';
 
+export const BotInfoSchema = z.object({
+  botAddress: AztecAddress.schema,
+});
+
+export type BotInfo = z.infer<typeof BotInfoSchema>;
+
 export interface BotRunnerApi {
   start(): Promise<void>;
   stop(): Promise<void>;
   run(): Promise<void>;
   setup(): Promise<void>;
   getConfig(): Promise<BotConfig>;
+  getInfo(): Promise<BotInfo>;
   update(config: BotConfig): Promise<void>;
 }
 
@@ -18,6 +26,7 @@ export const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi> = {
   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()),
 };

package/src/l1_to_l2_seeding.ts

@@ -0,0 +1,79 @@
+import { generateClaimSecret } from '@aztec/aztec.js/ethereum';
+import type { ExtendedViemWalletClient } from '@aztec/ethereum/types';
+import { compactArray } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { InboxAbi } from '@aztec/l1-artifacts';
+import type { AztecAddress } from '@aztec/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.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

@@ -1,21 +1,8 @@
 import type { ApiHandler } from '@aztec/foundation/json-rpc/server';
-import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
 
 import { BotRunnerApiSchema } from './interface.js';
 import type { BotRunner } from './runner.js';
 
-/**
- * Wraps a bot runner with a JSON RPC HTTP server.
- * @param botRunner - The BotRunner.
- * @returns An JSON-RPC HTTP server
- */
-export function createBotRunnerRpcServer(botRunner: BotRunner) {
-  createTracedJsonRpcServer(botRunner, BotRunnerApiSchema, {
-    http200OnError: false,
-    healthCheck: botRunner.isHealthy.bind(botRunner),
-  });
-}
-
 export function getBotRunnerApiHandler(botRunner: BotRunner): ApiHandler {
   return [botRunner, BotRunnerApiSchema, botRunner.isHealthy.bind(botRunner)];
 }

package/src/runner.ts

@@ -1,16 +1,22 @@
-import { type AztecNode, type PXE, createAztecNodeClient, createLogger } from '@aztec/aztec.js';
+import { createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { omit } from '@aztec/foundation/collection';
 import { RunningPromise } from '@aztec/foundation/running-promise';
-import { type TelemetryClient, type Traceable, type Tracer, makeTracedFetch, trackSpan } from '@aztec/telemetry-client';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { type TelemetryClient, type Traceable, type Tracer, trackSpan } from '@aztec/telemetry-client';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
+import { AmmBot } from './amm_bot.js';
+import type { BaseBot } from './base_bot.js';
 import { Bot } from './bot.js';
-import { type BotConfig, getVersions } from './config.js';
-import type { BotRunnerApi } from './interface.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<Bot>;
-  private pxe?: PXE;
-  private node: AztecNode;
+  private bot?: Promise<BaseBot>;
   private runningPromise: RunningPromise;
   private consecutiveErrors = 0;
   private healthy = true;
@@ -19,15 +25,14 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   public constructor(
     private config: BotConfig,
-    dependencies: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+    private readonly wallet: EmbeddedWallet,
+    private readonly aztecNode: AztecNode,
+    private readonly telemetry: TelemetryClient,
+    private readonly aztecNodeAdmin: AztecNodeAdmin | undefined,
+    private readonly store: BotStore,
   ) {
-    this.tracer = dependencies.telemetry.getTracer('Bot');
-    this.pxe = dependencies.pxe;
-    if (!dependencies.node && !config.nodeUrl) {
-      throw new Error(`Missing node URL in config or dependencies`);
-    }
-    this.node =
-      dependencies.node ?? createAztecNodeClient(config.nodeUrl!, getVersions(), makeTracedFetch([1, 2, 3], true));
+    this.tracer = telemetry.getTracer('Bot');
+
     this.runningPromise = new RunningPromise(() => this.#work(), this.log, config.txIntervalSeconds * 1000);
   }
 
@@ -65,6 +70,7 @@ export class BotRunner implements BotRunnerApi, Traceable {
       this.log.verbose(`Stopping bot`);
       await this.runningPromise.stop();
     }
+    await this.store.close();
     this.log.info(`Stopped bot`);
   }
 
@@ -126,12 +132,36 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   /** Returns the current configuration for the bot. */
   public getConfig() {
-    return Promise.resolve(this.config);
+    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 {
-      this.bot = Bot.create(this.config, { pxe: this.pxe, node: this.node });
+      switch (this.config.botMode) {
+        case 'crosschain':
+          this.bot = CrossChainBot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          break;
+        case 'amm':
+          this.bot = AmmBot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          break;
+        case 'transfer':
+          this.bot = Bot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
+          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}`);
@@ -142,16 +172,16 @@ export class BotRunner implements BotRunnerApi, Traceable {
   @trackSpan('Bot.work')
   async #work() {
     if (this.config.maxPendingTxs > 0) {
-      const pendingTxs = await this.node.getPendingTxs();
-      if (pendingTxs.length >= this.config.maxPendingTxs) {
-        this.log.verbose(`Not sending bot tx since node has ${pendingTxs.length} pending txs`);
+      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 (err) {
+    } catch {
       // Already logged in run()
       if (this.config.maxConsecutiveErrors > 0 && this.consecutiveErrors >= this.config.maxConsecutiveErrors) {
         this.log.error(`Too many errors bot is unhealthy`);

package/src/store/bot_store.ts

@@ -0,0 +1,196 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/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

@@ -1,4 +1,6 @@
-import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import { ContractBase } from '@aztec/aztec.js/contracts';
+import type { AMMContract } from '@aztec/noir-contracts.js/AMM';
+import type { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
@@ -11,17 +13,26 @@ import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 export async function getBalances(
   token: TokenContract,
   who: AztecAddress,
+  from?: AztecAddress,
 ): Promise<{ privateBalance: bigint; publicBalance: bigint }> {
-  const privateBalance = await token.methods.balance_of_private(who).simulate();
-  const publicBalance = await token.methods.balance_of_public(who).simulate();
+  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: EasyPrivateTokenContract, who: AztecAddress): Promise<bigint> {
-  const privateBalance = await token.methods.get_balance(who).simulate();
+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: TokenContract | EasyPrivateTokenContract): token is TokenContract {
+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;
+}