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

package/src/bot.ts

@@ -1,40 +1,47 @@
-import {
-  type AztecAddress,
-  BatchCall,
-  FeeJuicePaymentMethod,
-  type SendMethodOptions,
-  type Wallet,
-  createLogger,
-} from '@aztec/aztec.js';
-import { timesParallel } from '@aztec/foundation/collection';
-import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { BatchCall, NO_WAIT } from '@aztec/aztec.js/contracts';
+import { TxHash } from '@aztec/aztec.js/tx';
+import { times } from '@aztec/foundation/collection';
+import type { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
-import type { FunctionCall } from '@aztec/stdlib/abi';
-import { Gas } from '@aztec/stdlib/gas';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import type { EmbeddedWallet } from '@aztec/wallets/embedded';
 
+import { BaseBot } from './base_bot.js';
 import type { BotConfig } from './config.js';
 import { BotFactory } from './factory.js';
+import type { BotStore } from './store/index.js';
 import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
 
 const TRANSFER_AMOUNT = 1;
 
-export class Bot {
-  private log = createLogger('bot');
-
-  private attempts: number = 0;
-  private successes: number = 0;
-
+export class Bot extends BaseBot {
   protected constructor(
-    public readonly wallet: Wallet,
-    public readonly token: TokenContract | EasyPrivateTokenContract,
+    node: AztecNode,
+    wallet: EmbeddedWallet,
+    defaultAccountAddress: AztecAddress,
+    public readonly token: TokenContract | PrivateTokenContract,
     public readonly recipient: AztecAddress,
-    public config: BotConfig,
-  ) {}
+    config: BotConfig,
+  ) {
+    super(node, wallet, defaultAccountAddress, config);
+  }
 
-  static async create(config: BotConfig, dependencies: { pxe?: PXE; node?: AztecNode } = {}): Promise<Bot> {
-    const { wallet, token, recipient } = await new BotFactory(config, dependencies).setup();
-    return new Bot(wallet, token, recipient, config);
+  static async create(
+    config: BotConfig,
+    wallet: EmbeddedWallet,
+    aztecNode: AztecNode,
+    aztecNodeAdmin: AztecNodeAdmin | undefined,
+    store: BotStore,
+  ): Promise<Bot> {
+    const { defaultAccountAddress, token, recipient } = await new BotFactory(
+      config,
+      wallet,
+      store,
+      aztecNode,
+      aztecNodeAdmin,
+    ).setup();
+    return new Bot(aztecNode, wallet, defaultAccountAddress, token, recipient, config);
   }
 
   public updateConfig(config: Partial<BotConfig>) {
@@ -42,84 +49,47 @@ export class Bot {
     this.config = { ...this.config, ...config };
   }
 
-  public async run() {
-    this.attempts++;
-    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000) };
-    const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod, followChain, txMinedWaitSeconds } =
-      this.config;
+  protected async createAndSendTx(logCtx: object): Promise<TxHash> {
+    const { privateTransfersPerTx, publicTransfersPerTx, feePaymentMethod } = this.config;
     const { token, recipient, wallet } = this;
-    const sender = wallet.getAddress();
 
     this.log.verbose(
       `Preparing tx with ${feePaymentMethod} fee with ${privateTransfersPerTx} private and ${publicTransfersPerTx} public transfers`,
       logCtx,
     );
 
-    const calls: FunctionCall[] = [];
-    if (isStandardTokenContract(token)) {
-      calls.push(
-        ...(await timesParallel(privateTransfersPerTx, () =>
-          token.methods.transfer(recipient, TRANSFER_AMOUNT).request(),
-        )),
-      );
-      calls.push(
-        ...(await timesParallel(publicTransfersPerTx, () =>
-          token.methods.transfer_in_public(sender, recipient, TRANSFER_AMOUNT, 0).request(),
-        )),
-      );
-    } else {
-      calls.push(
-        ...(await timesParallel(privateTransfersPerTx, () =>
-          token.methods.transfer(TRANSFER_AMOUNT, sender, recipient).request(),
-        )),
-      );
-    }
+    const calls = isStandardTokenContract(token)
+      ? [
+          times(privateTransfersPerTx, () => token.methods.transfer(recipient, TRANSFER_AMOUNT)),
+          times(publicTransfersPerTx, () =>
+            token.methods.transfer_in_public(this.defaultAccountAddress, recipient, TRANSFER_AMOUNT, 0),
+          ),
+        ].flat()
+      : times(privateTransfersPerTx, () =>
+          token.methods.transfer(TRANSFER_AMOUNT, this.defaultAccountAddress, recipient),
+        );
 
-    const opts = this.getSendMethodOpts();
     const batch = new BatchCall(wallet, calls);
+    const opts = await this.getSendMethodOpts(batch);
 
     this.log.verbose(`Simulating transaction with ${calls.length}`, logCtx);
-    await batch.simulate();
-
-    this.log.verbose(`Proving transaction`, logCtx);
-    const provenTx = await batch.prove(opts);
-
-    this.log.verbose(`Sending tx`, logCtx);
-    const tx = provenTx.send();
-
-    const txHash = await tx.getTxHash();
-
-    if (followChain === 'NONE') {
-      this.log.info(`Transaction ${txHash} sent, not waiting for it to be mined`);
-      return;
-    }
+    await batch.simulate({ from: this.defaultAccountAddress });
 
-    this.log.verbose(
-      `Awaiting tx ${txHash} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
-      logCtx,
-    );
-    const receipt = await tx.wait({
-      timeout: txMinedWaitSeconds,
-      provenTimeout: txMinedWaitSeconds,
-      proven: followChain === 'PROVEN',
-    });
-    this.log.info(
-      `Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`,
-      logCtx,
-    );
-    this.successes++;
+    this.log.verbose(`Sending transaction`, logCtx);
+    const { txHash } = await batch.send({ ...opts, wait: NO_WAIT });
+    return txHash;
   }
 
   public async getBalances() {
     if (isStandardTokenContract(this.token)) {
       return {
-        sender: await getBalances(this.token, this.wallet.getAddress()),
+        sender: await getBalances(this.token, this.defaultAccountAddress),
         recipient: await getBalances(this.token, this.recipient),
       };
     } else {
       return {
         sender: {
-          privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+          privateBalance: await getPrivateBalance(this.token, this.defaultAccountAddress),
           publicBalance: 0n,
         },
         recipient: {
@@ -129,23 +99,4 @@ export class Bot {
       };
     }
   }
-
-  private getSendMethodOpts(): SendMethodOptions {
-    const sender = this.wallet.getAddress();
-    const { l2GasLimit, daGasLimit, skipPublicSimulation } = this.config;
-    const paymentMethod = new FeeJuicePaymentMethod(sender);
-
-    let gasSettings, estimateGas;
-    if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
-      gasSettings = { gasLimits: Gas.from({ l2Gas: l2GasLimit, daGas: daGasLimit }) };
-      estimateGas = false;
-      this.log.verbose(`Using gas limits ${l2GasLimit} L2 gas ${daGasLimit} DA gas`);
-    } else {
-      estimateGas = true;
-      this.log.verbose(`Estimating gas for transaction`);
-    }
-    const baseFeePadding = 2; // Send 3x the current base fee
-    this.log.verbose(skipPublicSimulation ? `Skipping public simulation` : `Simulating public transfers`);
-    return { fee: { estimateGas, paymentMethod, gasSettings, baseFeePadding }, skipPublicSimulation };
-  }
 }

package/src/config.ts

@@ -1,43 +1,53 @@
 import {
   type ConfigMappingsType,
+  SecretValue,
   booleanConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
   optionalNumberConfigHelper,
+  pickConfigMappings,
+  secretFrConfigHelper,
+  secretStringConfigHelper,
 } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
-import { type ZodFor, schemas } from '@aztec/stdlib/schemas';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/stdlib/kv-store';
+import { schemas, zodFor } from '@aztec/stdlib/schemas';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
 import { z } from 'zod';
 
-const BotFollowChain = ['NONE', 'PENDING', 'PROVEN'] as const;
+const BotFollowChain = ['NONE', 'PROPOSED', 'CHECKPOINTED', 'PROVEN'] as const;
 type BotFollowChain = (typeof BotFollowChain)[number];
 
+const BotMode = ['transfer', 'amm', 'crosschain'] as const;
+type BotMode = (typeof BotMode)[number];
+
 export enum SupportedTokenContracts {
   TokenContract = 'TokenContract',
-  EasyPrivateTokenContract = 'EasyPrivateTokenContract',
+  PrivateTokenContract = 'PrivateTokenContract',
 }
 
 export type BotConfig = {
   /** The URL to the Aztec node to check for tx pool status. */
   nodeUrl: string | undefined;
-  /** URL to the PXE for sending txs, or undefined if an in-proc PXE is used. */
-  pxeUrl: string | undefined;
+  /** The URL to the Aztec node admin API to force-flush txs if configured. */
+  nodeAdminUrl: string | undefined;
   /** Url of the ethereum host. */
   l1RpcUrls: string[] | undefined;
   /** The mnemonic for the account to bridge fee juice from L1. */
-  l1Mnemonic: string | undefined;
+  l1Mnemonic: SecretValue<string> | undefined;
   /** The private key for the account to bridge fee juice from L1. */
-  l1PrivateKey: string | undefined;
+  l1PrivateKey: SecretValue<string> | undefined;
+  /** How long to wait for L1 to L2 messages to become available on L2 */
+  l1ToL2MessageTimeoutSeconds: number;
   /** Signing private key for the sender account. */
-  senderPrivateKey: Fr | undefined;
-  /** Encryption secret for a recipient account. */
-  recipientEncryptionSecret: Fr;
-  /** Salt for the token contract deployment. */
+  senderPrivateKey: SecretValue<Fr> | undefined;
+  /** Optional salt to use to instantiate the sender account */
+  senderSalt: Fr | undefined;
+  /** Salt for the token contract instantiation. */
   tokenSalt: Fr;
   /** Every how many seconds should a new tx be sent. */
   txIntervalSeconds: number;
@@ -47,6 +57,8 @@ export type BotConfig = {
   publicTransfersPerTx: number;
   /** How to handle fee payments. */
   feePaymentMethod: 'fee_juice';
+  /** 'How much is the bot willing to overpay vs. the current min fee' */
+  minFeePadding: number;
   /** True to not automatically setup or start the bot on initialization. */
   noStart: boolean;
   /** How long to wait for a tx to be mined before reporting an error. */
@@ -57,8 +69,6 @@ export type BotConfig = {
   maxPendingTxs: number;
   /** Whether to flush after sending each 'setup' transaction */
   flushSetupTransactions: boolean;
-  /** Whether to skip public simulation of txs before sending them. */
-  skipPublicSimulation: boolean;
   /** L2 gas limit for the tx (empty to have the bot trigger an estimate gas). */
   l2GasLimit: number | undefined;
   /** DA gas limit for the tx (empty to have the bot trigger an estimate gas). */
@@ -69,54 +79,70 @@ export type BotConfig = {
   maxConsecutiveErrors: number;
   /** Stops the bot if service becomes unhealthy */
   stopWhenUnhealthy: boolean;
-};
+  /** Bot mode: transfer, amm, or crosschain. */
+  botMode: BotMode;
+  /** Number of L2→L1 messages per tx (crosschain mode). */
+  l2ToL1MessagesPerTx: number;
+  /** Max L1→L2 messages to keep in-flight (crosschain mode). */
+  l1ToL2SeedCount: number;
+} & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'>;
 
-export const BotConfigSchema = z
-  .object({
-    nodeUrl: z.string().optional(),
-    pxeUrl: z.string().optional(),
-    l1RpcUrls: z.array(z.string()).optional(),
-    l1Mnemonic: z.string().optional(),
-    l1PrivateKey: z.string().optional(),
-    senderPrivateKey: schemas.Fr.optional(),
-    recipientEncryptionSecret: schemas.Fr,
-    tokenSalt: schemas.Fr,
-    txIntervalSeconds: z.number(),
-    privateTransfersPerTx: z.number().int().nonnegative(),
-    publicTransfersPerTx: z.number().int().nonnegative(),
-    feePaymentMethod: z.literal('fee_juice'),
-    noStart: z.boolean(),
-    txMinedWaitSeconds: z.number(),
-    followChain: z.enum(BotFollowChain),
-    maxPendingTxs: z.number().int().nonnegative(),
-    flushSetupTransactions: z.boolean(),
-    skipPublicSimulation: z.boolean(),
-    l2GasLimit: z.number().int().nonnegative().optional(),
-    daGasLimit: z.number().int().nonnegative().optional(),
-    contract: z.nativeEnum(SupportedTokenContracts),
-    maxConsecutiveErrors: z.number().int().nonnegative(),
-    stopWhenUnhealthy: z.boolean(),
-  })
-  .transform(config => ({
-    nodeUrl: undefined,
-    pxeUrl: undefined,
-    l1RpcUrls: undefined,
-    l1Mnemonic: undefined,
-    l1PrivateKey: undefined,
-    senderPrivateKey: undefined,
-    l2GasLimit: undefined,
-    daGasLimit: undefined,
-    ...config,
-  })) satisfies ZodFor<BotConfig>;
+export const BotConfigSchema = zodFor<BotConfig>()(
+  z
+    .object({
+      nodeUrl: z.string().optional(),
+      nodeAdminUrl: z.string().optional(),
+      l1RpcUrls: z.array(z.string()).optional(),
+      l1Mnemonic: schemas.SecretValue(z.string()).optional(),
+      l1PrivateKey: schemas.SecretValue(z.string()).optional(),
+      l1ToL2MessageTimeoutSeconds: z.number(),
+      senderPrivateKey: schemas.SecretValue(schemas.Fr).optional(),
+      senderSalt: schemas.Fr.optional(),
+      tokenSalt: schemas.Fr,
+      txIntervalSeconds: z.number(),
+      privateTransfersPerTx: z.number().int().nonnegative(),
+      publicTransfersPerTx: z.number().int().nonnegative(),
+      feePaymentMethod: z.literal('fee_juice'),
+      minFeePadding: z.number().int().nonnegative(),
+      noStart: z.boolean(),
+      txMinedWaitSeconds: z.number(),
+      followChain: z.enum(BotFollowChain),
+      maxPendingTxs: z.number().int().nonnegative(),
+      flushSetupTransactions: z.boolean(),
+      l2GasLimit: z.number().int().nonnegative().optional(),
+      daGasLimit: z.number().int().nonnegative().optional(),
+      contract: z.nativeEnum(SupportedTokenContracts),
+      maxConsecutiveErrors: z.number().int().nonnegative(),
+      stopWhenUnhealthy: z.boolean(),
+      botMode: z.enum(BotMode).default('transfer'),
+      l2ToL1MessagesPerTx: z.number().int().nonnegative().default(1),
+      l1ToL2SeedCount: z.number().int().nonnegative().default(1),
+      dataDirectory: z.string().optional(),
+      dataStoreMapSizeKb: z.number().optional(),
+    })
+    .transform(config => ({
+      nodeUrl: undefined,
+      nodeAdminUrl: undefined,
+      l1RpcUrls: undefined,
+      senderSalt: undefined,
+      l2GasLimit: undefined,
+      daGasLimit: undefined,
+      l1Mnemonic: undefined,
+      l1PrivateKey: undefined,
+      senderPrivateKey: undefined,
+      dataStoreMapSizeKb: 1_024 * 1_024,
+      ...config,
+    })),
+);
 
 export const botConfigMappings: ConfigMappingsType<BotConfig> = {
   nodeUrl: {
     env: 'AZTEC_NODE_URL',
     description: 'The URL to the Aztec node to check for tx pool status.',
   },
-  pxeUrl: {
-    env: 'BOT_PXE_URL',
-    description: 'URL to the PXE for sending txs, or undefined if an in-proc PXE is used.',
+  nodeAdminUrl: {
+    env: 'AZTEC_NODE_ADMIN_URL',
+    description: 'The URL to the Aztec node admin API to force-flush txs if configured.',
   },
   l1RpcUrls: {
     env: 'ETHEREUM_HOSTS',
@@ -126,25 +152,31 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
   l1Mnemonic: {
     env: 'BOT_L1_MNEMONIC',
     description: 'The mnemonic for the account to bridge fee juice from L1.',
+    ...secretStringConfigHelper(),
   },
   l1PrivateKey: {
     env: 'BOT_L1_PRIVATE_KEY',
     description: 'The private key for the account to bridge fee juice from L1.',
+    ...secretStringConfigHelper(),
+  },
+  l1ToL2MessageTimeoutSeconds: {
+    env: 'BOT_L1_TO_L2_TIMEOUT_SECONDS',
+    description: 'How long to wait for L1 to L2 messages to become available on L2',
+    ...numberConfigHelper(3600),
   },
   senderPrivateKey: {
     env: 'BOT_PRIVATE_KEY',
     description: 'Signing private key for the sender account.',
-    parseEnv: (val: string) => (val ? Fr.fromHexString(val) : undefined),
+    ...secretFrConfigHelper(),
   },
-  recipientEncryptionSecret: {
-    env: 'BOT_RECIPIENT_ENCRYPTION_SECRET',
-    description: 'Encryption secret for a recipient account.',
-    parseEnv: (val: string) => Fr.fromHexString(val),
-    defaultValue: Fr.fromHexString('0xcafecafe'),
+  senderSalt: {
+    env: 'BOT_ACCOUNT_SALT',
+    description: 'The salt to use to deploy the sender account.',
+    parseEnv: (val: string) => (val ? Fr.fromHexString(val) : undefined),
   },
   tokenSalt: {
     env: 'BOT_TOKEN_SALT',
-    description: 'Salt for the token contract deployment.',
+    description: 'The salt to use to deploy the token contract.',
     parseEnv: (val: string) => Fr.fromHexString(val),
     defaultValue: Fr.fromHexString('1'),
   },
@@ -169,6 +201,11 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     parseEnv: val => (val as 'fee_juice') || undefined,
     defaultValue: 'fee_juice',
   },
+  minFeePadding: {
+    env: 'BOT_MIN_FEE_PADDING',
+    description: 'How much is the bot willing to overpay vs. the current base fee',
+    ...numberConfigHelper(3),
+  },
   noStart: {
     env: 'BOT_NO_START',
     description: 'True to not automatically setup or start the bot on initialization.',
@@ -184,10 +221,14 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Which chain the bot follows',
     defaultValue: 'NONE',
     parseEnv(val) {
-      if (!(BotFollowChain as readonly string[]).includes(val.toUpperCase())) {
+      const upper = val.toUpperCase();
+      if (upper === 'PENDING') {
+        return 'CHECKPOINTED';
+      }
+      if (!(BotFollowChain as readonly string[]).includes(upper)) {
         throw new Error(`Invalid value for BOT_FOLLOW_CHAIN: ${val}`);
       }
-      return val as BotFollowChain;
+      return upper as BotFollowChain;
     },
   },
   maxPendingTxs: {
@@ -200,11 +241,6 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Make a request for the sequencer to build a block after each setup transaction.',
     ...booleanConfigHelper(false),
   },
-  skipPublicSimulation: {
-    env: 'BOT_SKIP_PUBLIC_SIMULATION',
-    description: 'Whether to skip public simulation of txs before sending them.',
-    ...booleanConfigHelper(false),
-  },
   l2GasLimit: {
     env: 'BOT_L2_GAS_LIMIT',
     description: 'L2 gas limit for the tx (empty to have the bot trigger an estimate gas).',
@@ -240,6 +276,28 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Stops the bot if service becomes unhealthy',
     ...booleanConfigHelper(false),
   },
+  botMode: {
+    env: 'BOT_MODE',
+    description: 'Bot mode: transfer, amm, or crosschain',
+    defaultValue: 'transfer' as BotMode,
+    parseEnv(val: string) {
+      if (!(BotMode as readonly string[]).includes(val)) {
+        throw new Error(`Invalid value for BOT_MODE: ${val}`);
+      }
+      return val as BotMode;
+    },
+  },
+  l2ToL1MessagesPerTx: {
+    env: 'BOT_L2_TO_L1_MESSAGES_PER_TX',
+    description: 'Number of L2→L1 messages per tx (crosschain mode)',
+    ...numberConfigHelper(1),
+  },
+  l1ToL2SeedCount: {
+    env: 'BOT_L1_TO_L2_SEED_COUNT',
+    description: 'Max L1→L2 messages to keep in-flight (crosschain mode)',
+    ...numberConfigHelper(1),
+  },
+  ...pickConfigMappings(dataConfigMappings, ['dataStoreMapSizeKb', 'dataDirectory']),
 };
 
 export function getBotConfigFromEnv(): BotConfig {
@@ -252,7 +310,7 @@ export function getBotDefaultConfig(): BotConfig {
 
 export function getVersions(): Partial<ComponentsVersions> {
   return {
-    l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+    l2ProtocolContractsHash: protocolContractsHash.toString(),
     l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
   };
 }