@aztec/bot 0.0.0-test.0

package/src/bot.ts

@@ -0,0 +1,151 @@
+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 { 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 { BotConfig } from './config.js';
+import { BotFactory } from './factory.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;
+
+  protected constructor(
+    public readonly wallet: Wallet,
+    public readonly token: TokenContract | EasyPrivateTokenContract,
+    public readonly recipient: AztecAddress,
+    public config: BotConfig,
+  ) {}
+
+  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);
+  }
+
+  public updateConfig(config: Partial<BotConfig>) {
+    this.log.info(`Updating bot config ${Object.keys(config).join(', ')}`);
+    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;
+    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 opts = this.getSendMethodOpts();
+    const batch = new BatchCall(wallet, calls);
+
+    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;
+    }
+
+    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++;
+  }
+
+  public async getBalances() {
+    if (isStandardTokenContract(this.token)) {
+      return {
+        sender: await getBalances(this.token, this.wallet.getAddress()),
+        recipient: await getBalances(this.token, this.recipient),
+      };
+    } else {
+      return {
+        sender: {
+          privateBalance: await getPrivateBalance(this.token, this.wallet.getAddress()),
+          publicBalance: 0n,
+        },
+        recipient: {
+          privateBalance: await getPrivateBalance(this.token, this.recipient),
+          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

@@ -0,0 +1,258 @@
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  getDefaultConfig,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/fields';
+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 type { ComponentsVersions } from '@aztec/stdlib/versioning';
+
+import { z } from 'zod';
+
+const BotFollowChain = ['NONE', 'PENDING', 'PROVEN'] as const;
+type BotFollowChain = (typeof BotFollowChain)[number];
+
+export enum SupportedTokenContracts {
+  TokenContract = 'TokenContract',
+  EasyPrivateTokenContract = 'EasyPrivateTokenContract',
+}
+
+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;
+  /** Url of the ethereum host. */
+  l1RpcUrls: string[] | undefined;
+  /** The mnemonic for the account to bridge fee juice from L1. */
+  l1Mnemonic: string | undefined;
+  /** The private key for the account to bridge fee juice from L1. */
+  l1PrivateKey: string | undefined;
+  /** Signing private key for the sender account. */
+  senderPrivateKey: Fr | undefined;
+  /** Encryption secret for a recipient account. */
+  recipientEncryptionSecret: Fr;
+  /** Salt for the token contract deployment. */
+  tokenSalt: Fr;
+  /** Every how many seconds should a new tx be sent. */
+  txIntervalSeconds: number;
+  /** How many private token transfers are executed per tx. */
+  privateTransfersPerTx: number;
+  /** How many public token transfers are executed per tx. */
+  publicTransfersPerTx: number;
+  /** How to handle fee payments. */
+  feePaymentMethod: 'fee_juice';
+  /** 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. */
+  txMinedWaitSeconds: number;
+  /** Whether to wait for txs to be proven, to be mined, or no wait at all. */
+  followChain: BotFollowChain;
+  /** Do not send a tx if the node's tx pool already has this many pending txs. */
+  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). */
+  daGasLimit: number | undefined;
+  /** Token contract to use */
+  contract: SupportedTokenContracts;
+  /** The maximum number of consecutive errors before the bot shuts down */
+  maxConsecutiveErrors: number;
+  /** Stops the bot if service becomes unhealthy */
+  stopWhenUnhealthy: boolean;
+};
+
+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 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.',
+  },
+  l1RpcUrls: {
+    env: 'ETHEREUM_HOSTS',
+    description: 'URL of the ethereum host.',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+  },
+  l1Mnemonic: {
+    env: 'BOT_L1_MNEMONIC',
+    description: 'The mnemonic for the account to bridge fee juice from L1.',
+  },
+  l1PrivateKey: {
+    env: 'BOT_L1_PRIVATE_KEY',
+    description: 'The private key for the account to bridge fee juice from L1.',
+  },
+  senderPrivateKey: {
+    env: 'BOT_PRIVATE_KEY',
+    description: 'Signing private key for the sender account.',
+    parseEnv: (val: string) => (val ? Fr.fromHexString(val) : undefined),
+  },
+  recipientEncryptionSecret: {
+    env: 'BOT_RECIPIENT_ENCRYPTION_SECRET',
+    description: 'Encryption secret for a recipient account.',
+    parseEnv: (val: string) => Fr.fromHexString(val),
+    defaultValue: Fr.fromHexString('0xcafecafe'),
+  },
+  tokenSalt: {
+    env: 'BOT_TOKEN_SALT',
+    description: 'Salt for the token contract deployment.',
+    parseEnv: (val: string) => Fr.fromHexString(val),
+    defaultValue: Fr.fromHexString('1'),
+  },
+  txIntervalSeconds: {
+    env: 'BOT_TX_INTERVAL_SECONDS',
+    description: 'Every how many seconds should a new tx be sent.',
+    ...numberConfigHelper(60),
+  },
+  privateTransfersPerTx: {
+    env: 'BOT_PRIVATE_TRANSFERS_PER_TX',
+    description: 'How many private token transfers are executed per tx.',
+    ...numberConfigHelper(1),
+  },
+  publicTransfersPerTx: {
+    env: 'BOT_PUBLIC_TRANSFERS_PER_TX',
+    description: 'How many public token transfers are executed per tx.',
+    ...numberConfigHelper(1),
+  },
+  feePaymentMethod: {
+    env: 'BOT_FEE_PAYMENT_METHOD',
+    description: 'How to handle fee payments. (Options: fee_juice)',
+    parseEnv: val => (val as 'fee_juice') || undefined,
+    defaultValue: 'fee_juice',
+  },
+  noStart: {
+    env: 'BOT_NO_START',
+    description: 'True to not automatically setup or start the bot on initialization.',
+    ...booleanConfigHelper(),
+  },
+  txMinedWaitSeconds: {
+    env: 'BOT_TX_MINED_WAIT_SECONDS',
+    description: 'How long to wait for a tx to be mined before reporting an error.',
+    ...numberConfigHelper(180),
+  },
+  followChain: {
+    env: 'BOT_FOLLOW_CHAIN',
+    description: 'Which chain the bot follows',
+    defaultValue: 'NONE',
+    parseEnv(val) {
+      if (!(BotFollowChain as readonly string[]).includes(val.toUpperCase())) {
+        throw new Error(`Invalid value for BOT_FOLLOW_CHAIN: ${val}`);
+      }
+      return val as BotFollowChain;
+    },
+  },
+  maxPendingTxs: {
+    env: 'BOT_MAX_PENDING_TXS',
+    description: "Do not send a tx if the node's tx pool already has this many pending txs.",
+    ...numberConfigHelper(128),
+  },
+  flushSetupTransactions: {
+    env: 'BOT_FLUSH_SETUP_TRANSACTIONS',
+    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).',
+    ...optionalNumberConfigHelper(),
+  },
+  daGasLimit: {
+    env: 'BOT_DA_GAS_LIMIT',
+    description: 'DA gas limit for the tx (empty to have the bot trigger an estimate gas).',
+    ...optionalNumberConfigHelper(),
+  },
+  contract: {
+    env: 'BOT_TOKEN_CONTRACT',
+    description: 'Token contract to use',
+    defaultValue: SupportedTokenContracts.TokenContract,
+    parseEnv(val) {
+      if (!Object.values(SupportedTokenContracts).includes(val as any)) {
+        throw new Error(
+          `Invalid value for BOT_TOKEN_CONTRACT: ${val}. Valid values: ${Object.values(SupportedTokenContracts).join(
+            ', ',
+          )}`,
+        );
+      }
+      return val as SupportedTokenContracts;
+    },
+  },
+  maxConsecutiveErrors: {
+    env: 'BOT_MAX_CONSECUTIVE_ERRORS',
+    description: 'The maximum number of consecutive errors before the bot shuts down',
+    ...numberConfigHelper(0),
+  },
+  stopWhenUnhealthy: {
+    env: 'BOT_STOP_WHEN_UNHEALTHY',
+    description: 'Stops the bot if service becomes unhealthy',
+    ...booleanConfigHelper(false),
+  },
+};
+
+export function getBotConfigFromEnv(): BotConfig {
+  return getConfigFromMappings<BotConfig>(botConfigMappings);
+}
+
+export function getBotDefaultConfig(): BotConfig {
+  return getDefaultConfig<BotConfig>(botConfigMappings);
+}
+
+export function getVersions(): Partial<ComponentsVersions> {
+  return {
+    l2ProtocolContractsTreeRoot: protocolContractTreeRoot.toString(),
+    l2CircuitsVkTreeRoot: getVKTreeRoot().toString(),
+  };
+}

package/src/factory.ts

@@ -0,0 +1,259 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { getDeployedTestAccountsWallets, getInitialTestAccounts } from '@aztec/accounts/testing';
+import {
+  type AccountWallet,
+  AztecAddress,
+  type AztecNode,
+  BatchCall,
+  type DeployMethod,
+  type DeployOptions,
+  FeeJuicePaymentMethodWithClaim,
+  L1FeeJuicePortalManager,
+  type PXE,
+  createLogger,
+  createPXEClient,
+  retryUntil,
+} from '@aztec/aztec.js';
+import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
+import { Fr } from '@aztec/foundation/fields';
+import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
+import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { deriveSigningKey } from '@aztec/stdlib/keys';
+import { makeTracedFetch } from '@aztec/telemetry-client';
+
+import { type BotConfig, SupportedTokenContracts, getVersions } from './config.js';
+import { getBalances, getPrivateBalance, isStandardTokenContract } from './utils.js';
+
+const MINT_BALANCE = 1e12;
+const MIN_BALANCE = 1e3;
+
+export class BotFactory {
+  private pxe: PXE;
+  private node?: AztecNode;
+  private log = createLogger('bot');
+
+  constructor(private readonly config: BotConfig, dependencies: { pxe?: PXE; node?: AztecNode } = {}) {
+    if (config.flushSetupTransactions && !dependencies.node) {
+      throw new Error(`Either a node client or node url must be provided if transaction flushing is requested`);
+    }
+    if (config.senderPrivateKey && !dependencies.node) {
+      throw new Error(
+        `Either a node client or node url must be provided for bridging L1 fee juice to deploy an account with private key`,
+      );
+    }
+    if (!dependencies.pxe && !config.pxeUrl) {
+      throw new Error(`Either a PXE client or a PXE URL must be provided`);
+    }
+
+    this.node = dependencies.node;
+
+    if (dependencies.pxe) {
+      this.log.info(`Using local PXE`);
+      this.pxe = dependencies.pxe;
+      return;
+    }
+    this.log.info(`Using remote PXE at ${config.pxeUrl!}`);
+    this.pxe = createPXEClient(config.pxeUrl!, getVersions(), makeTracedFetch([1, 2, 3], false));
+  }
+
+  /**
+   * Initializes a new bot by setting up the sender account, registering the recipient,
+   * deploying the token contract, and minting tokens if necessary.
+   */
+  public async setup() {
+    const recipient = await this.registerRecipient();
+    const wallet = await this.setupAccount();
+    const token = await this.setupToken(wallet);
+    await this.mintTokens(token);
+    return { wallet, token, pxe: this.pxe, recipient };
+  }
+
+  /**
+   * Checks if the sender account contract is initialized, and initializes it if necessary.
+   * @returns The sender wallet.
+   */
+  private async setupAccount() {
+    if (this.config.senderPrivateKey) {
+      return await this.setupAccountWithPrivateKey(this.config.senderPrivateKey);
+    } else {
+      return await this.setupTestAccount();
+    }
+  }
+
+  private async setupAccountWithPrivateKey(privateKey: Fr) {
+    const salt = Fr.ONE;
+    const signingKey = deriveSigningKey(privateKey);
+    const account = await getSchnorrAccount(this.pxe, privateKey, signingKey, salt);
+    const isInit = (await this.pxe.getContractMetadata(account.getAddress())).isContractInitialized;
+    if (isInit) {
+      this.log.info(`Account at ${account.getAddress().toString()} already initialized`);
+      const wallet = await account.register();
+      return wallet;
+    } else {
+      const address = account.getAddress();
+      this.log.info(`Deploying account at ${address}`);
+
+      const claim = await this.bridgeL1FeeJuice(address, 10n ** 22n);
+
+      const wallet = await account.getWallet();
+      const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claim);
+      const sentTx = account.deploy({ fee: { paymentMethod } });
+      const txHash = await sentTx.getTxHash();
+      this.log.info(`Sent tx with hash ${txHash.toString()}`);
+      await this.tryFlushTxs();
+      this.log.verbose('Waiting for account deployment to settle');
+      await sentTx.wait({ timeout: this.config.txMinedWaitSeconds });
+      this.log.info(`Account deployed at ${address}`);
+      return wallet;
+    }
+  }
+
+  private async setupTestAccount() {
+    let [wallet] = await getDeployedTestAccountsWallets(this.pxe);
+    if (wallet) {
+      this.log.info(`Using funded test account: ${wallet.getAddress()}`);
+    } else {
+      this.log.info('Registering funded test account');
+      const [account] = await getInitialTestAccounts();
+      const manager = await getSchnorrAccount(this.pxe, account.secret, account.signingKey, account.salt);
+      wallet = await manager.register();
+      this.log.info(`Funded test account registered: ${wallet.getAddress()}`);
+    }
+    return wallet;
+  }
+
+  /**
+   * Registers the recipient for txs in the pxe.
+   */
+  private async registerRecipient() {
+    const recipient = await this.pxe.registerAccount(this.config.recipientEncryptionSecret, Fr.ONE);
+    return recipient.address;
+  }
+
+  /**
+   * Checks if the token contract is deployed and deploys it if necessary.
+   * @param wallet - Wallet to deploy the token contract from.
+   * @returns The TokenContract instance.
+   */
+  private async setupToken(wallet: AccountWallet): Promise<TokenContract | EasyPrivateTokenContract> {
+    let deploy: DeployMethod<TokenContract | EasyPrivateTokenContract>;
+    const deployOpts: DeployOptions = { contractAddressSalt: this.config.tokenSalt, universalDeploy: true };
+    if (this.config.contract === SupportedTokenContracts.TokenContract) {
+      deploy = TokenContract.deploy(wallet, wallet.getAddress(), 'BotToken', 'BOT', 18);
+    } else if (this.config.contract === SupportedTokenContracts.EasyPrivateTokenContract) {
+      deploy = EasyPrivateTokenContract.deploy(wallet, MINT_BALANCE, wallet.getAddress());
+      deployOpts.skipPublicDeployment = true;
+      deployOpts.skipClassRegistration = true;
+      deployOpts.skipInitialization = false;
+      deployOpts.skipPublicSimulation = true;
+    } else {
+      throw new Error(`Unsupported token contract type: ${this.config.contract}`);
+    }
+
+    const address = (await deploy.getInstance(deployOpts)).address;
+    if ((await this.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+      this.log.info(`Token at ${address.toString()} already deployed`);
+      return deploy.register();
+    } else {
+      this.log.info(`Deploying token contract at ${address.toString()}`);
+      const sentTx = deploy.send(deployOpts);
+      const txHash = await sentTx.getTxHash();
+      this.log.info(`Sent tx with hash ${txHash.toString()}`);
+      await this.tryFlushTxs();
+      this.log.verbose('Waiting for token setup to settle');
+      return sentTx.deployed({ timeout: this.config.txMinedWaitSeconds });
+    }
+  }
+
+  /**
+   * Mints private and public tokens for the sender if their balance is below the minimum.
+   * @param token - Token contract.
+   */
+  private async mintTokens(token: TokenContract | EasyPrivateTokenContract) {
+    const sender = token.wallet.getAddress();
+    const isStandardToken = isStandardTokenContract(token);
+    let privateBalance = 0n;
+    let publicBalance = 0n;
+
+    if (isStandardToken) {
+      ({ privateBalance, publicBalance } = await getBalances(token, sender));
+    } else {
+      privateBalance = await getPrivateBalance(token, sender);
+    }
+
+    const calls: FunctionCall[] = [];
+    if (privateBalance < MIN_BALANCE) {
+      this.log.info(`Minting private tokens for ${sender.toString()}`);
+
+      const from = sender; // we are setting from to sender here because we need a sender to calculate the tag
+      calls.push(
+        isStandardToken
+          ? await token.methods.mint_to_private(from, sender, MINT_BALANCE).request()
+          : await token.methods.mint(MINT_BALANCE, sender).request(),
+      );
+    }
+    if (isStandardToken && publicBalance < MIN_BALANCE) {
+      this.log.info(`Minting public tokens for ${sender.toString()}`);
+      calls.push(await token.methods.mint_to_public(sender, MINT_BALANCE).request());
+    }
+    if (calls.length === 0) {
+      this.log.info(`Skipping minting as ${sender.toString()} has enough tokens`);
+      return;
+    }
+    const sentTx = new BatchCall(token.wallet, calls).send();
+    const txHash = await sentTx.getTxHash();
+    this.log.info(`Sent tx with hash ${txHash.toString()}`);
+    await this.tryFlushTxs();
+    this.log.verbose('Waiting for token mint to settle');
+    await sentTx.wait({ timeout: this.config.txMinedWaitSeconds });
+  }
+
+  private async bridgeL1FeeJuice(recipient: AztecAddress, amount: bigint) {
+    const l1RpcUrls = this.config.l1RpcUrls;
+    if (!l1RpcUrls?.length) {
+      throw new Error('L1 Rpc url is required to bridge the fee juice to fund the deployment of the account.');
+    }
+    const mnemonicOrPrivateKey = this.config.l1PrivateKey || this.config.l1Mnemonic;
+    if (!mnemonicOrPrivateKey) {
+      throw new Error(
+        'Either a mnemonic or private key of an L1 account is required to bridge the fee juice to fund the deployment of the account.',
+      );
+    }
+
+    const { l1ChainId } = await this.pxe.getNodeInfo();
+    const chain = createEthereumChain(l1RpcUrls, l1ChainId);
+    const { publicClient, walletClient } = createL1Clients(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
+
+    const portal = await L1FeeJuicePortalManager.new(this.pxe, publicClient, walletClient, this.log);
+    const claim = await portal.bridgeTokensPublic(recipient, amount, true /* mint */);
+
+    const isSynced = async () => await this.pxe.isL1ToL2MessageSynced(Fr.fromHexString(claim.messageHash));
+    await retryUntil(isSynced, `message ${claim.messageHash} sync`, 24, 1);
+
+    this.log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
+
+    // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
+    await this.advanceL2Block();
+    await this.advanceL2Block();
+
+    return claim;
+  }
+
+  private async advanceL2Block() {
+    const initialBlockNumber = await this.node!.getBlockNumber();
+    await this.tryFlushTxs();
+    await retryUntil(async () => (await this.node!.getBlockNumber()) >= initialBlockNumber + 1);
+  }
+
+  private async tryFlushTxs() {
+    if (this.config.flushSetupTransactions) {
+      this.log.verbose('Flushing transactions');
+      try {
+        await this.node!.flushTxs();
+      } catch (err) {
+        this.log.error(`Failed to flush transactions: ${err}`);
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+export { Bot } from './bot.js';
+export { BotRunner } from './runner.js';
+export {
+  type BotConfig,
+  getBotConfigFromEnv,
+  getBotDefaultConfig,
+  botConfigMappings,
+  SupportedTokenContracts,
+} from './config.js';
+export { createBotRunnerRpcServer, getBotRunnerApiHandler } from './rpc.js';
+export * from './interface.js';