@aztec/bot 0.0.0-test.1 → 0.0.1-commit.5daedc8

package/src/base_bot.ts

@@ -0,0 +1,96 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import {
+  BatchCall,
+  ContractFunctionInteraction,
+  type SendInteractionOptions,
+  SentTx,
+  waitForProven,
+} from '@aztec/aztec.js/contracts';
+import { createLogger } from '@aztec/aztec.js/log';
+import { TxHash, TxReceipt } from '@aztec/aztec.js/tx';
+import { Gas } from '@aztec/stdlib/gas';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { TestWallet } from '@aztec/test-wallet/server';
+
+import type { BotConfig } from './config.js';
+
+export abstract class BaseBot {
+  protected log = createLogger('bot');
+
+  protected attempts: number = 0;
+  protected successes: number = 0;
+
+  protected constructor(
+    public readonly node: AztecNode,
+    public readonly wallet: TestWallet,
+    public readonly defaultAccountAddress: AztecAddress,
+    public config: BotConfig,
+  ) {}
+
+  public async run(): Promise<TxReceipt | TxHash> {
+    this.attempts++;
+    const logCtx = { runId: Date.now() * 1000 + Math.floor(Math.random() * 1000) };
+    const { followChain, txMinedWaitSeconds } = this.config;
+
+    this.log.verbose(`Creating tx`, logCtx);
+    const tx = await this.createAndSendTx(logCtx);
+
+    const txHash = await tx.getTxHash();
+
+    if (followChain === 'NONE') {
+      this.log.info(`Transaction ${txHash.toString()} sent, not waiting for it to be mined`);
+      return txHash;
+    }
+
+    this.log.verbose(
+      `Awaiting tx ${txHash.toString()} to be on the ${followChain} chain (timeout ${txMinedWaitSeconds}s)`,
+      logCtx,
+    );
+    const receipt = await tx.wait({
+      timeout: txMinedWaitSeconds,
+    });
+    if (followChain === 'PROVEN') {
+      await waitForProven(this.node, receipt, { provenTimeout: txMinedWaitSeconds });
+    }
+    this.successes++;
+    this.log.info(
+      `Tx #${this.attempts} ${receipt.txHash} successfully mined in block ${receipt.blockNumber} (stats: ${this.successes}/${this.attempts} success)`,
+      logCtx,
+    );
+
+    await this.onTxMined(receipt, logCtx);
+
+    return receipt;
+  }
+
+  protected abstract createAndSendTx(logCtx: object): Promise<SentTx>;
+
+  protected onTxMined(_receipt: TxReceipt, _logCtx: object): Promise<void> {
+    // no-op
+    return Promise.resolve();
+  }
+
+  protected async getSendMethodOpts(
+    interaction: ContractFunctionInteraction | BatchCall,
+  ): Promise<SendInteractionOptions> {
+    const { l2GasLimit, daGasLimit, baseFeePadding } = this.config;
+
+    this.wallet.setBaseFeePadding(baseFeePadding);
+
+    let gasSettings;
+    if (l2GasLimit !== undefined && l2GasLimit > 0 && daGasLimit !== undefined && daGasLimit > 0) {
+      gasSettings = { gasLimits: Gas.from({ l2Gas: l2GasLimit, daGas: daGasLimit }) };
+      this.log.verbose(`Using gas limits ${l2GasLimit} L2 gas ${daGasLimit} DA gas`);
+    } else {
+      this.log.verbose(`Estimating gas for transaction`);
+      ({ estimatedGas: gasSettings } = await interaction.simulate({
+        fee: { estimateGas: true },
+        from: this.defaultAccountAddress,
+      }));
+    }
+    return {
+      from: this.defaultAccountAddress,
+      fee: { gasSettings },
+    };
+  }
+}

package/src/bot.ts

@@ -1,40 +1,46 @@
-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, SentTx } from '@aztec/aztec.js/contracts';
+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 { TestWallet } from '@aztec/test-wallet/server';
 
+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: TestWallet,
+    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: TestWallet,
+    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,110 +48,53 @@ 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<SentTx> {
+    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);
+    return batch.send(opts);
   }
 
   public async getBalances() {
     if (isStandardTokenContract(this.token)) {
       return {
-        sender: await getBalances(this.token, this.wallet.getAddress()),
-        recipient: await getBalances(this.token, this.recipient),
+        sender: await getBalances(this.token, this.defaultAccountAddress),
+        recipient: await getBalances(this.token, this.recipient, this.defaultAccountAddress),
       };
     } else {
       return {
         sender: {
-          privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+          privateBalance: await getPrivateBalance(this.token, this.defaultAccountAddress),
           publicBalance: 0n,
         },
         recipient: {
-          privateBalance: await getPrivateBalance(this.token, this.recipient),
+          privateBalance: await getPrivateBalance(this.token, this.recipient, this.defaultAccountAddress),
           publicBalance: 0n,
         },
       };
     }
   }
-
-  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,14 +1,19 @@
 import {
   type ConfigMappingsType,
+  SecretValue,
   booleanConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
   optionalNumberConfigHelper,
+  pickConfigMappings,
+  secretFrConfigHelper,
+  secretStringConfigHelper,
 } from '@aztec/foundation/config';
 import { Fr } from '@aztec/foundation/fields';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
-import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { type ZodFor, schemas } from '@aztec/stdlib/schemas';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
@@ -19,25 +24,27 @@ type BotFollowChain = (typeof BotFollowChain)[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 +54,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 base fee' */
+  baseFeePadding: 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 +66,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,43 +76,52 @@ export type BotConfig = {
   maxConsecutiveErrors: number;
   /** Stops the bot if service becomes unhealthy */
   stopWhenUnhealthy: boolean;
-};
+  /** Deploy an AMM contract and do swaps instead of transfers */
+  ammTxs: boolean;
+} & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'>;
 
 export const BotConfigSchema = z
   .object({
     nodeUrl: z.string().optional(),
-    pxeUrl: z.string().optional(),
+    nodeAdminUrl: z.string().optional(),
     l1RpcUrls: z.array(z.string()).optional(),
-    l1Mnemonic: z.string().optional(),
-    l1PrivateKey: z.string().optional(),
-    senderPrivateKey: schemas.Fr.optional(),
-    recipientEncryptionSecret: schemas.Fr,
+    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'),
+    baseFeePadding: z.number().int().nonnegative(),
     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(),
+    ammTxs: z.boolean().default(false),
+    dataDirectory: z.string().optional(),
+    dataStoreMapSizeKb: z.number().optional(),
   })
   .transform(config => ({
     nodeUrl: undefined,
-    pxeUrl: undefined,
+    nodeAdminUrl: undefined,
     l1RpcUrls: undefined,
+    senderSalt: undefined,
+    l2GasLimit: undefined,
+    daGasLimit: undefined,
     l1Mnemonic: undefined,
     l1PrivateKey: undefined,
     senderPrivateKey: undefined,
-    l2GasLimit: undefined,
-    daGasLimit: undefined,
+    dataDirectory: undefined,
+    dataStoreMapSizeKb: 1_024 * 1_024,
     ...config,
   })) satisfies ZodFor<BotConfig>;
 
@@ -114,9 +130,9 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     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 +142,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 +191,11 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     parseEnv: val => (val as 'fee_juice') || undefined,
     defaultValue: 'fee_juice',
   },
+  baseFeePadding: {
+    env: 'BOT_BASE_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.',
@@ -200,11 +227,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 +262,12 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Stops the bot if service becomes unhealthy',
     ...booleanConfigHelper(false),
   },
+  ammTxs: {
+    env: 'BOT_AMM_TXS',
+    description: 'Deploy an AMM and send swaps to it',
+    ...booleanConfigHelper(false),
+  },
+  ...pickConfigMappings(dataConfigMappings, ['dataStoreMapSizeKb', 'dataDirectory']),
 };
 
 export function getBotConfigFromEnv(): BotConfig {
@@ -252,7 +280,7 @@ export function getBotDefaultConfig(): BotConfig {
 
 export function getVersions(): Partial<ComponentsVersions> {
   return {
-    l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+    l2ProtocolContractsHash: protocolContractsHash.toString(),
     l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
   };
 }