@aztec/bot 0.0.0-test.0

package/src/interface.ts

@@ -0,0 +1,23 @@
+import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
+
+import { z } from 'zod';
+
+import { type BotConfig, BotConfigSchema } from './config.js';
+
+export interface BotRunnerApi {
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  run(): Promise<void>;
+  setup(): Promise<void>;
+  getConfig(): Promise<BotConfig>;
+  update(config: BotConfig): Promise<void>;
+}
+
+export const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi> = {
+  start: z.function().args().returns(z.void()),
+  stop: z.function().args().returns(z.void()),
+  run: z.function().args().returns(z.void()),
+  setup: z.function().args().returns(z.void()),
+  getConfig: z.function().args().returns(BotConfigSchema),
+  update: z.function().args(BotConfigSchema).returns(z.void()),
+};

package/src/rpc.ts

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

@@ -0,0 +1,167 @@
+import { type AztecNode, type PXE, createAztecNodeClient, createLogger } from '@aztec/aztec.js';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type TelemetryClient, type Traceable, type Tracer, makeTracedFetch, trackSpan } from '@aztec/telemetry-client';
+
+import { Bot } from './bot.js';
+import { type BotConfig, getVersions } from './config.js';
+import type { BotRunnerApi } from './interface.js';
+
+export class BotRunner implements BotRunnerApi, Traceable {
+  private log = createLogger('bot');
+  private bot?: Promise<Bot>;
+  private pxe?: PXE;
+  private node: AztecNode;
+  private runningPromise: RunningPromise;
+  private consecutiveErrors = 0;
+  private healthy = true;
+
+  public readonly tracer: Tracer;
+
+  public constructor(
+    private config: BotConfig,
+    dependencies: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+  ) {
+    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.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();
+    }
+    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() {
+    return Promise.resolve(this.config);
+  }
+
+  async #createBot() {
+    try {
+      this.bot = Bot.create(this.config, { pxe: this.pxe, node: this.node });
+      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 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`);
+        return;
+      }
+    }
+
+    try {
+      await this.run();
+    } catch (err) {
+      // 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/utils.ts

@@ -0,0 +1,27 @@
+import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import type { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { AztecAddress } from '@aztec/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,
+): 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();
+  return { privateBalance, publicBalance };
+}
+
+export async function getPrivateBalance(token: EasyPrivateTokenContract, who: AztecAddress): Promise<bigint> {
+  const privateBalance = await token.methods.get_balance(who).simulate();
+  return privateBalance;
+}
+
+export function isStandardTokenContract(token: TokenContract | EasyPrivateTokenContract): token is TokenContract {
+  return 'mint_to_public' in token.methods;
+}