@aztec/bot 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/runner.ts

@@ -1,16 +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 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 { BotRunnerApi } from './interface.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<Bot>;
-  private pxe?: PXE;
-  private node: AztecNode;
+  private bot?: Promise<BaseBot>;
   private runningPromise: RunningPromise;
   private consecutiveErrors = 0;
   private healthy = true;
@@ -19,15 +24,14 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   public constructor(
     private config: BotConfig,
-    dependencies: { pxe?: PXE; node?: AztecNode; 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`);
-    }
-    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 +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`);
   }
 
@@ -126,12 +131,24 @@ 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 });
+      this.bot = this.config.ammTxs
+        ? 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}`);
@@ -142,16 +159,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,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,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 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: 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 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;
+}