@aztec/bot 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/index.ts

@@ -1,6 +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,

package/src/interface.ts

@@ -1,4 +1,4 @@
-import { AztecAddress } from '@aztec/aztec.js';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 
 import { z } from 'zod';

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/runner.ts

@@ -1,21 +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 AztecNodeAdmin, createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
-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 { 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 pxe?: PXE;
-  private node: AztecNode;
-  private nodeAdmin?: AztecNodeAdmin;
   private runningPromise: RunningPromise;
   private consecutiveErrors = 0;
   private healthy = true;
@@ -24,19 +25,14 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   public constructor(
     private config: BotConfig,
-    dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin; 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`);
-    }
-    const versions = getVersions();
-    const fetch = makeTracedFetch([1, 2, 3], true);
-    this.node = dependencies.node ?? createAztecNodeClient(config.nodeUrl!, versions, fetch);
-    this.nodeAdmin =
-      dependencies.nodeAdmin ??
-      (config.nodeAdminUrl ? createAztecNodeAdminClient(config.nodeAdminUrl, versions, fetch) : undefined);
+    this.tracer = telemetry.getTracer('Bot');
+
     this.runningPromise = new RunningPromise(() => this.#work(), this.log, config.txIntervalSeconds * 1000);
   }
 
@@ -74,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`);
   }
 
@@ -144,15 +141,27 @@ export class BotRunner implements BotRunnerApi, Traceable {
     if (!this.bot) {
       throw new Error(`Bot is not initialized`);
     }
-    const botAddress = await this.bot.then(b => b.wallet.getAddress());
+    const botAddress = await this.bot.then(b => b.defaultAccountAddress);
     return { botAddress };
   }
 
   async #createBot() {
     try {
-      this.bot = this.config.ammTxs
-        ? AmmBot.create(this.config, { pxe: this.pxe, node: this.node, nodeAdmin: this.nodeAdmin })
-        : Bot.create(this.config, { pxe: this.pxe, node: this.node, nodeAdmin: this.nodeAdmin });
+      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}`);
@@ -163,7 +172,7 @@ export class BotRunner implements BotRunnerApi, Traceable {
   @trackSpan('Bot.work')
   async #work() {
     if (this.config.maxPendingTxs > 0) {
-      const pendingTxCount = await this.node.getPendingTxCount();
+      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;

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,4 @@
-import type { ContractBase } from '@aztec/aztec.js';
+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';
@@ -13,14 +13,19 @@ 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({ from: who });
-  const publicBalance = await token.methods.balance_of_public(who).simulate({ from: who });
+  const privateBalance = await token.methods.balance_of_private(who).simulate({ from: from ?? who });
+  const publicBalance = await token.methods.balance_of_public(who).simulate({ from: from ?? who });
   return { privateBalance, publicBalance };
 }
 
-export async function getPrivateBalance(token: PrivateTokenContract, who: AztecAddress): Promise<bigint> {
-  const privateBalance = await token.methods.get_balance(who).simulate({ from: who });
+export async function getPrivateBalance(
+  token: PrivateTokenContract,
+  who: AztecAddress,
+  from?: AztecAddress,
+): Promise<bigint> {
+  const privateBalance = await token.methods.get_balance(who).simulate({ from: from ?? who });
   return privateBalance;
 }