@aztec/bot 2.1.0-rc.9 → 3.0.0-devnet.2

package/src/runner.ts

@@ -1,21 +1,21 @@
-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 { TestWallet } from '@aztec/test-wallet/server';
 
 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 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 +24,14 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   public constructor(
     private config: BotConfig,
-    dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin; telemetry: TelemetryClient },
+    private readonly wallet: TestWallet,
+    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 +69,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 +140,15 @@ 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 });
+        ? AmmBot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store)
+        : Bot.create(this.config, this.wallet, this.aztecNode, this.aztecNodeAdmin, this.store);
       await this.bot;
     } catch (err) {
       this.log.error(`Error setting up bot: ${err}`);
@@ -163,7 +159,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,141 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
+
+export interface BridgeClaimData {
+  claim: L2AmountClaim;
+  timestamp: number;
+  recipient: string;
+}
+
+/**
+ * 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>;
+
+  constructor(
+    private readonly store: AztecAsyncKVStore,
+    private readonly log: Logger = createLogger('bot:store'),
+  ) {
+    this.bridgeClaims = store.openMap<string, string>('bridge_claims');
+  }
+
+  /**
+   * 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: Date.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 = Date.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;
+  }
+
+  /**
+   * 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 } 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;
 }