@aztec/bot 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/src/factory.ts

@@ -1,72 +1,97 @@
-import { getSchnorrAccount } from '@aztec/accounts/schnorr';
-import { getDeployedTestAccountsWallets, getInitialTestAccounts } from '@aztec/accounts/testing';
+import { SchnorrAccountContract } from '@aztec/accounts/schnorr';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import {
-  type AccountWallet,
-  AztecAddress,
-  type AztecNode,
   BatchCall,
+  ContractBase,
+  ContractFunctionInteraction,
   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';
+} from '@aztec/aztec.js/contracts';
+import { L1FeeJuicePortalManager } from '@aztec/aztec.js/ethereum';
+import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
+import { FeeJuicePaymentMethodWithClaim } from '@aztec/aztec.js/fee';
+import { deriveKeys } from '@aztec/aztec.js/keys';
+import { createLogger } from '@aztec/aztec.js/log';
+import { waitForL1ToL2MessageReady } from '@aztec/aztec.js/messaging';
+import { createEthereumChain } from '@aztec/ethereum/chain';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Timer } from '@aztec/foundation/timer';
+import { AMMContract } from '@aztec/noir-contracts.js/AMM';
+import { PrivateTokenContract } from '@aztec/noir-contracts.js/PrivateToken';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
-import type { FunctionCall } from '@aztec/stdlib/abi';
+import type { ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+import { GasSettings } from '@aztec/stdlib/gas';
+import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
-import { makeTracedFetch } from '@aztec/telemetry-client';
+import { TestWallet } from '@aztec/test-wallet/server';
 
-import { type BotConfig, SupportedTokenContracts, getVersions } from './config.js';
+import { type BotConfig, SupportedTokenContracts } from './config.js';
+import type { BotStore } from './store/index.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));
-  }
+  constructor(
+    private readonly config: BotConfig,
+    private readonly wallet: TestWallet,
+    private readonly store: BotStore,
+    private readonly aztecNode: AztecNode,
+    private readonly aztecNodeAdmin?: AztecNodeAdmin,
+  ) {}
 
   /**
    * 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 };
+  public async setup(): Promise<{
+    wallet: TestWallet;
+    defaultAccountAddress: AztecAddress;
+    token: TokenContract | PrivateTokenContract;
+    node: AztecNode;
+    recipient: AztecAddress;
+  }> {
+    const recipient = (await this.wallet.createAccount()).address;
+    const defaultAccountAddress = await this.setupAccount();
+    const token = await this.setupToken(defaultAccountAddress);
+    await this.mintTokens(token, defaultAccountAddress);
+    return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
+  }
+
+  public async setupAmm(): Promise<{
+    wallet: TestWallet;
+    defaultAccountAddress: AztecAddress;
+    amm: AMMContract;
+    token0: TokenContract;
+    token1: TokenContract;
+    node: AztecNode;
+  }> {
+    const defaultAccountAddress = await this.setupAccount();
+    const token0 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken0', 'BOT0');
+    const token1 = await this.setupTokenContract(defaultAccountAddress, this.config.tokenSalt, 'BotToken1', 'BOT1');
+    const liquidityToken = await this.setupTokenContract(
+      defaultAccountAddress,
+      this.config.tokenSalt,
+      'BotLPToken',
+      'BOTLP',
+    );
+    const amm = await this.setupAmmContract(
+      defaultAccountAddress,
+      this.config.tokenSalt,
+      token0,
+      token1,
+      liquidityToken,
+    );
+
+    await this.fundAmm(defaultAccountAddress, defaultAccountAddress, amm, token0, token1, liquidityToken);
+    this.log.info(`AMM initialized and funded`);
+
+    return { wallet: this.wallet, defaultAccountAddress, amm, token0, token1, node: this.aztecNode };
   }
 
   /**
@@ -74,61 +99,65 @@ export class BotFactory {
    * @returns The sender wallet.
    */
   private async setupAccount() {
-    if (this.config.senderPrivateKey) {
-      return await this.setupAccountWithPrivateKey(this.config.senderPrivateKey);
+    const privateKey = this.config.senderPrivateKey?.getValue();
+    if (privateKey) {
+      this.log.info(`Setting up account with provided private key`);
+      return await this.setupAccountWithPrivateKey(privateKey);
     } else {
+      this.log.info(`Setting up test account`);
       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;
+  private async setupAccountWithPrivateKey(secret: Fr) {
+    const salt = this.config.senderSalt ?? Fr.ONE;
+    const signingKey = deriveSigningKey(secret);
+    const accountData = {
+      secret,
+      salt,
+      contract: new SchnorrAccountContract(signingKey!),
+    };
+    const accountManager = await this.wallet.createAccount(accountData);
+    const isInit = (await this.wallet.getContractMetadata(accountManager.address)).isContractInitialized;
     if (isInit) {
-      this.log.info(`Account at ${account.getAddress().toString()} already initialized`);
-      const wallet = await account.register();
-      return wallet;
+      this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
+      const timer = new Timer();
+      const address = accountManager.address;
+      this.log.info(`Account at ${address} registered. duration=${timer.ms()}`);
+      await this.store.deleteBridgeClaim(address);
+      return address;
     } else {
-      const address = account.getAddress();
+      const address = accountManager.address;
       this.log.info(`Deploying account at ${address}`);
 
-      const claim = await this.bridgeL1FeeJuice(address, 10n ** 22n);
+      const claim = await this.getOrCreateBridgeClaim(address);
 
-      const wallet = await account.getWallet();
-      const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claim);
-      const sentTx = account.deploy({ fee: { paymentMethod } });
+      const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
+      const deployMethod = await accountManager.getDeployMethod();
+      const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.config.baseFeePadding);
+      const gasSettings = GasSettings.default({ maxFeesPerGas });
+      const sentTx = deployMethod.send({ from: AztecAddress.ZERO, fee: { gasSettings, 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(`Sent tx for account deployment with hash ${txHash.toString()}`);
+      await this.withNoMinTxsPerBlock(() => 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()}`);
+      // Clean up the consumed bridge claim
+      await this.store.deleteBridgeClaim(address);
+
+      return accountManager.address;
     }
-    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;
+  private async setupTestAccount() {
+    const [initialAccountData] = await getInitialTestAccountsData();
+    const accountData = {
+      secret: initialAccountData.secret,
+      salt: initialAccountData.salt,
+      contract: new SchnorrAccountContract(initialAccountData.signingKey),
+    };
+    const accountManager = await this.wallet.createAccount(accountData);
+    return accountManager.address;
   }
 
   /**
@@ -136,33 +165,175 @@ export class BotFactory {
    * @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 };
+  private async setupToken(sender: AztecAddress): Promise<TokenContract | PrivateTokenContract> {
+    let deploy: DeployMethod<TokenContract | PrivateTokenContract>;
+    let tokenInstance: ContractInstanceWithAddress | undefined;
+    const deployOpts: DeployOptions = {
+      from: sender,
+      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;
+      deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
+    } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
+      // Generate keys for the contract since PrivateToken uses SinglePrivateMutable which requires keys
+      const tokenSecretKey = Fr.random();
+      const tokenPublicKeys = (await deriveKeys(tokenSecretKey)).publicKeys;
+      deploy = PrivateTokenContract.deployWithPublicKeys(tokenPublicKeys, this.wallet, MINT_BALANCE, sender);
+      deployOpts.skipInstancePublication = true;
+      deployOpts.skipClassPublication = true;
       deployOpts.skipInitialization = false;
-      deployOpts.skipPublicSimulation = true;
+
+      // Register the contract with the secret key before deployment
+      tokenInstance = await deploy.getInstance(deployOpts);
+      await this.wallet.registerContract(tokenInstance, PrivateTokenContract.artifact, tokenSecretKey);
     } 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) {
+    const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
+    if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
       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 });
+      this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
+      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
+    }
+  }
+
+  /**
+   * 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 setupTokenContract(
+    deployer: AztecAddress,
+    contractAddressSalt: Fr,
+    name: string,
+    ticker: string,
+    decimals = 18,
+  ): Promise<TokenContract> {
+    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
+    const deploy = TokenContract.deploy(this.wallet, deployer, name, ticker, decimals);
+    return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+  }
+
+  private async setupAmmContract(
+    deployer: AztecAddress,
+    contractAddressSalt: Fr,
+    token0: TokenContract,
+    token1: TokenContract,
+    lpToken: TokenContract,
+  ): Promise<AMMContract> {
+    const deployOpts: DeployOptions = { from: deployer, contractAddressSalt, universalDeploy: true };
+    const deploy = AMMContract.deploy(this.wallet, token0.address, token1.address, lpToken.address);
+    const amm = await this.registerOrDeployContract('AMM', deploy, deployOpts);
+
+    this.log.info(`AMM deployed at ${amm.address}`);
+    const minterTx = lpToken.methods.set_minter(amm.address, true).send({ from: deployer });
+    this.log.info(`Set LP token minter to AMM txHash=${(await minterTx.getTxHash()).toString()}`);
+    await minterTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Liquidity token initialized`);
+
+    return amm;
+  }
+
+  private async fundAmm(
+    defaultAccountAddress: AztecAddress,
+    liquidityProvider: AztecAddress,
+    amm: AMMContract,
+    token0: TokenContract,
+    token1: TokenContract,
+    lpToken: TokenContract,
+  ): Promise<void> {
+    const getPrivateBalances = () =>
+      Promise.all([
+        token0.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
+        token1.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
+        lpToken.methods.balance_of_private(liquidityProvider).simulate({ from: liquidityProvider }),
+      ]);
+
+    const authwitNonce = Fr.random();
+
+    // keep some tokens for swapping
+    const amount0Max = MINT_BALANCE / 2;
+    const amount0Min = MINT_BALANCE / 4;
+    const amount1Max = MINT_BALANCE / 2;
+    const amount1Min = MINT_BALANCE / 4;
+
+    const [t0Bal, t1Bal, lpBal] = await getPrivateBalances();
+
+    this.log.info(
+      `Minting ${MINT_BALANCE} tokens of each BotToken0 and BotToken1. Current private balances of ${liquidityProvider}: token0=${t0Bal}, token1=${t1Bal}, lp=${lpBal}`,
+    );
+
+    // Add authwitnesses for the transfers in AMM::add_liquidity function
+    const token0Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
+      caller: amm.address,
+      call: await token0.methods
+        .transfer_to_public_and_prepare_private_balance_increase(
+          liquidityProvider,
+          amm.address,
+          amount0Max,
+          authwitNonce,
+        )
+        .getFunctionCall(),
+    });
+    const token1Authwit = await this.wallet.createAuthWit(defaultAccountAddress, {
+      caller: amm.address,
+      call: await token1.methods
+        .transfer_to_public_and_prepare_private_balance_increase(
+          liquidityProvider,
+          amm.address,
+          amount1Max,
+          authwitNonce,
+        )
+        .getFunctionCall(),
+    });
+
+    const mintTx = new BatchCall(this.wallet, [
+      token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
+      token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
+    ]).send({ from: liquidityProvider });
+
+    this.log.info(`Sent mint tx: ${(await mintTx.getTxHash()).toString()}`);
+    await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
+
+    const addLiquidityTx = amm.methods
+      .add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce)
+      .send({
+        from: liquidityProvider,
+        authWitnesses: [token0Authwit, token1Authwit],
+      });
+
+    this.log.info(`Sent tx to add liquidity to the AMM: ${(await addLiquidityTx.getTxHash()).toString()}`);
+    await addLiquidityTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Liquidity added`);
+
+    const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
+    this.log.info(
+      `Updated private balances of ${defaultAccountAddress} after minting and funding AMM: token0=${newT0Bal}, token1=${newT1Bal}, lp=${newLPBal}`,
+    );
+  }
+
+  private async registerOrDeployContract<T extends ContractBase>(
+    name: string,
+    deploy: DeployMethod<T>,
+    deployOpts: DeployOptions,
+  ): Promise<T> {
+    const address = (await deploy.getInstance(deployOpts)).address;
+    if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
+      this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
+      return deploy.register();
+    } else {
+      this.log.info(`Deploying contract ${name} at ${address.toString()}`);
+      const sentTx = deploy.send(deployOpts);
+      const txHash = await sentTx.getTxHash();
+      this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
+      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
     }
   }
 
@@ -170,90 +341,119 @@ export class BotFactory {
    * 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();
+  private async mintTokens(token: TokenContract | PrivateTokenContract, minter: AztecAddress) {
     const isStandardToken = isStandardTokenContract(token);
     let privateBalance = 0n;
     let publicBalance = 0n;
 
     if (isStandardToken) {
-      ({ privateBalance, publicBalance } = await getBalances(token, sender));
+      ({ privateBalance, publicBalance } = await getBalances(token, minter));
     } else {
-      privateBalance = await getPrivateBalance(token, sender);
+      privateBalance = await getPrivateBalance(token, minter);
     }
 
-    const calls: FunctionCall[] = [];
+    const calls: ContractFunctionInteraction[] = [];
     if (privateBalance < MIN_BALANCE) {
-      this.log.info(`Minting private tokens for ${sender.toString()}`);
+      this.log.info(`Minting private tokens for ${minter.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(),
+          ? token.methods.mint_to_private(minter, MINT_BALANCE)
+          : token.methods.mint(MINT_BALANCE, minter),
       );
     }
     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());
+      this.log.info(`Minting public tokens for ${minter.toString()}`);
+      calls.push(token.methods.mint_to_public(minter, MINT_BALANCE));
     }
     if (calls.length === 0) {
-      this.log.info(`Skipping minting as ${sender.toString()} has enough tokens`);
+      this.log.info(`Skipping minting as ${minter.toString()} has enough tokens`);
       return;
     }
-    const sentTx = new BatchCall(token.wallet, calls).send();
+    const sentTx = new BatchCall(token.wallet, calls).send({ from: minter });
     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 });
+    this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
+    await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
   }
 
-  private async bridgeL1FeeJuice(recipient: AztecAddress, amount: bigint) {
+  /**
+   * Gets or creates a bridge claim for the recipient.
+   * Checks if a claim already exists in the store and reuses it if valid.
+   * Only creates a new bridge if fee juice balance is below threshold.
+   */
+  private async getOrCreateBridgeClaim(recipient: AztecAddress): Promise<L2AmountClaim> {
+    // Check if we have an existing claim in the store
+    const existingClaim = await this.store.getBridgeClaim(recipient);
+    if (existingClaim) {
+      this.log.info(`Found existing bridge claim for ${recipient.toString()}, checking validity...`);
+
+      // Check if the message is ready on L2
+      try {
+        const messageHash = Fr.fromHexString(existingClaim.claim.messageHash);
+        await this.withNoMinTxsPerBlock(() =>
+          waitForL1ToL2MessageReady(this.aztecNode, messageHash, {
+            timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+            forPublicConsumption: false,
+          }),
+        );
+        return existingClaim.claim;
+      } catch (err) {
+        this.log.warn(`Failed to verify existing claim, creating new one: ${err}`);
+        await this.store.deleteBridgeClaim(recipient);
+      }
+    }
+
+    const claim = await this.bridgeL1FeeJuice(recipient);
+    await this.store.saveBridgeClaim(recipient, claim);
+
+    return claim;
+  }
+
+  private async bridgeL1FeeJuice(recipient: AztecAddress): Promise<L2AmountClaim> {
     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;
+    const mnemonicOrPrivateKey = this.config.l1PrivateKey?.getValue() ?? this.config.l1Mnemonic?.getValue();
     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 { l1ChainId } = await this.aztecNode.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);
+    const extendedClient = createExtendedL1Client(chain.rpcUrls, mnemonicOrPrivateKey, chain.chainInfo);
 
-    this.log.info(`Created a claim for ${amount} L1 fee juice to ${recipient}.`, claim);
+    const portal = await L1FeeJuicePortalManager.new(this.aztecNode, extendedClient, this.log);
+    const mintAmount = await portal.getTokenManager().getMintAmount();
+    const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true /* mint */);
 
-    // Progress by 2 L2 blocks so that the l1ToL2Message added above will be available to use on L2.
-    await this.advanceL2Block();
-    await this.advanceL2Block();
+    await this.withNoMinTxsPerBlock(() =>
+      waitForL1ToL2MessageReady(this.aztecNode, Fr.fromHexString(claim.messageHash), {
+        timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
+        forPublicConsumption: false,
+      }),
+    );
 
-    return claim;
-  }
+    this.log.info(`Created a claim for ${mintAmount} L1 fee juice to ${recipient}.`, claim);
 
-  private async advanceL2Block() {
-    const initialBlockNumber = await this.node!.getBlockNumber();
-    await this.tryFlushTxs();
-    await retryUntil(async () => (await this.node!.getBlockNumber()) >= initialBlockNumber + 1);
+    return claim as L2AmountClaim;
   }
 
-  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}`);
-      }
+  private async withNoMinTxsPerBlock<T>(fn: () => Promise<T>): Promise<T> {
+    if (!this.aztecNodeAdmin || !this.config.flushSetupTransactions) {
+      this.log.verbose(`No node admin client or flushing not requested (not setting minTxsPerBlock to 0)`);
+      return fn();
+    }
+    const { minTxsPerBlock } = await this.aztecNodeAdmin.getConfig();
+    this.log.warn(`Setting sequencer minTxsPerBlock to 0 from ${minTxsPerBlock} to flush setup transactions`);
+    await this.aztecNodeAdmin.setConfig({ minTxsPerBlock: 0 });
+    try {
+      return await fn();
+    } finally {
+      this.log.warn(`Restoring sequencer minTxsPerBlock to ${minTxsPerBlock}`);
+      await this.aztecNodeAdmin.setConfig({ minTxsPerBlock });
     }
   }
 }

package/src/index.ts

@@ -1,5 +1,7 @@
 export { Bot } from './bot.js';
+export { AmmBot } from './amm_bot.js';
 export { BotRunner } from './runner.js';
+export { BotStore } from './store/bot_store.js';
 export {
   type BotConfig,
   getBotConfigFromEnv,
@@ -7,5 +9,5 @@ export {
   botConfigMappings,
   SupportedTokenContracts,
 } from './config.js';
-export { createBotRunnerRpcServer, getBotRunnerApiHandler } from './rpc.js';
+export { getBotRunnerApiHandler } from './rpc.js';
 export * from './interface.js';

package/src/interface.ts

@@ -1,15 +1,23 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 
 import { z } from 'zod';
 
 import { type BotConfig, BotConfigSchema } from './config.js';
 
+export const BotInfoSchema = z.object({
+  botAddress: AztecAddress.schema,
+});
+
+export type BotInfo = z.infer<typeof BotInfoSchema>;
+
 export interface BotRunnerApi {
   start(): Promise<void>;
   stop(): Promise<void>;
   run(): Promise<void>;
   setup(): Promise<void>;
   getConfig(): Promise<BotConfig>;
+  getInfo(): Promise<BotInfo>;
   update(config: BotConfig): Promise<void>;
 }
 
@@ -18,6 +26,7 @@ export const BotRunnerApiSchema: ApiSchemaFor<BotRunnerApi> = {
   stop: z.function().args().returns(z.void()),
   run: z.function().args().returns(z.void()),
   setup: z.function().args().returns(z.void()),
+  getInfo: z.function().args().returns(BotInfoSchema),
   getConfig: z.function().args().returns(BotConfigSchema),
   update: z.function().args(BotConfigSchema).returns(z.void()),
 };