@aztec/bot 0.81.0 → 0.82.0

package/src/config.ts

@@ -25,6 +25,8 @@ export enum SupportedTokenContracts {
 export type BotConfig = {
   /** The URL to the Aztec node to check for tx pool status. */
   nodeUrl: string | undefined;
+  /** The URL to the Aztec node admin API to force-flush txs if configured. */
+  nodeAdminUrl: 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. */
@@ -35,6 +37,8 @@ export type BotConfig = {
   l1PrivateKey: string | undefined;
   /** Signing private key for the sender account. */
   senderPrivateKey: Fr | undefined;
+  /** Optional salt to use to deploy the sender account */
+  senderSalt: Fr | undefined;
   /** Encryption secret for a recipient account. */
   recipientEncryptionSecret: Fr;
   /** Salt for the token contract deployment. */
@@ -69,16 +73,20 @@ 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;
 };
 
 export const BotConfigSchema = z
   .object({
     nodeUrl: z.string().optional(),
+    nodeAdminUrl: 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(),
+    senderSalt: schemas.Fr.optional(),
     recipientEncryptionSecret: schemas.Fr,
     tokenSalt: schemas.Fr,
     txIntervalSeconds: z.number(),
@@ -96,14 +104,17 @@ export const BotConfigSchema = z
     contract: z.nativeEnum(SupportedTokenContracts),
     maxConsecutiveErrors: z.number().int().nonnegative(),
     stopWhenUnhealthy: z.boolean(),
+    ammTxs: z.boolean().default(false),
   })
   .transform(config => ({
     nodeUrl: undefined,
+    nodeAdminUrl: undefined,
     pxeUrl: undefined,
     l1RpcUrls: undefined,
     l1Mnemonic: undefined,
     l1PrivateKey: undefined,
     senderPrivateKey: undefined,
+    senderSalt: undefined,
     l2GasLimit: undefined,
     daGasLimit: undefined,
     ...config,
@@ -114,6 +125,10 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     env: 'AZTEC_NODE_URL',
     description: 'The URL to the Aztec node to check for tx pool status.',
   },
+  nodeAdminUrl: {
+    env: 'AZTEC_NODE_ADMIN_URL',
+    description: 'The URL to the Aztec node admin API to force-flush txs if configured.',
+  },
   pxeUrl: {
     env: 'BOT_PXE_URL',
     description: 'URL to the PXE for sending txs, or undefined if an in-proc PXE is used.',
@@ -136,6 +151,11 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     description: 'Signing private key for the sender account.',
     parseEnv: (val: string) => (val ? Fr.fromHexString(val) : undefined),
   },
+  senderSalt: {
+    env: 'BOT_ACCOUNT_SALT',
+    description: 'The salt to use to deploys the sender account.',
+    parseEnv: (val: string) => (val ? Fr.fromHexString(val) : undefined),
+  },
   recipientEncryptionSecret: {
     env: 'BOT_RECIPIENT_ENCRYPTION_SECRET',
     description: 'Encryption secret for a recipient account.',
@@ -240,6 +260,11 @@ 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),
+  },
 };
 
 export function getBotConfigFromEnv(): BotConfig {

package/src/factory.ts

@@ -3,8 +3,8 @@ import { getDeployedTestAccountsWallets, getInitialTestAccounts } from '@aztec/a
 import {
   type AccountWallet,
   AztecAddress,
-  type AztecNode,
   BatchCall,
+  ContractBase,
   ContractFunctionInteraction,
   type DeployMethod,
   type DeployOptions,
@@ -17,8 +17,10 @@ import {
 } from '@aztec/aztec.js';
 import { createEthereumChain, createL1Clients } from '@aztec/ethereum';
 import { Fr } from '@aztec/foundation/fields';
+import { AMMContract } from '@aztec/noir-contracts.js/AMM';
 import { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
+import type { AztecNode, AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { deriveSigningKey } from '@aztec/stdlib/keys';
 import { makeTracedFetch } from '@aztec/telemetry-client';
 
@@ -31,11 +33,17 @@ const MIN_BALANCE = 1e3;
 export class BotFactory {
   private pxe: PXE;
   private node?: AztecNode;
+  private nodeAdmin?: AztecNodeAdmin;
   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`);
+  constructor(
+    private readonly config: BotConfig,
+    dependencies: { pxe?: PXE; nodeAdmin?: AztecNodeAdmin; node?: AztecNode },
+  ) {
+    if (config.flushSetupTransactions && !dependencies.nodeAdmin) {
+      throw new Error(
+        `Either a node admin client or node admin url must be provided if transaction flushing is requested`,
+      );
     }
     if (config.senderPrivateKey && !dependencies.node) {
       throw new Error(
@@ -47,6 +55,7 @@ export class BotFactory {
     }
 
     this.node = dependencies.node;
+    this.nodeAdmin = dependencies.nodeAdmin;
 
     if (dependencies.pxe) {
       this.log.info(`Using local PXE`);
@@ -69,6 +78,19 @@ export class BotFactory {
     return { wallet, token, pxe: this.pxe, recipient };
   }
 
+  public async setupAmm() {
+    const wallet = await this.setupAccount();
+    const token0 = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotToken0', 'BOT0');
+    const token1 = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotToken1', 'BOT1');
+    const liquidityToken = await this.setupTokenContract(wallet, this.config.tokenSalt, 'BotLPToken', 'BOTLP');
+    const amm = await this.setupAmmContract(wallet, this.config.tokenSalt, token0, token1, liquidityToken);
+
+    await this.fundAmm(wallet, amm, token0, token1);
+    this.log.info(`AMM initialized and funded`);
+
+    return { wallet, amm, token0, token1, pxe: this.pxe };
+  }
+
   /**
    * Checks if the sender account contract is initialized, and initializes it if necessary.
    * @returns The sender wallet.
@@ -82,7 +104,7 @@ export class BotFactory {
   }
 
   private async setupAccountWithPrivateKey(privateKey: Fr) {
-    const salt = Fr.ONE;
+    const salt = this.config.senderSalt ?? Fr.ONE;
     const signingKey = deriveSigningKey(privateKey);
     const account = await getSchnorrAccount(this.pxe, privateKey, signingKey, salt);
     const isInit = (await this.pxe.getContractMetadata(account.getAddress())).isContractInitialized;
@@ -94,12 +116,14 @@ export class BotFactory {
       const address = account.getAddress();
       this.log.info(`Deploying account at ${address}`);
 
-      const claim = await this.bridgeL1FeeJuice(address, 10n ** 22n);
+      const claim = await this.bridgeL1FeeJuice(address);
 
+      // docs:start:claim_and_deploy
       const wallet = await account.getWallet();
       const paymentMethod = new FeeJuicePaymentMethodWithClaim(wallet, claim);
       const sentTx = account.deploy({ fee: { paymentMethod } });
       const txHash = await sentTx.getTxHash();
+      // docs:end:claim_and_deploy
       this.log.info(`Sent tx with hash ${txHash.toString()}`);
       await this.tryFlushTxs();
       this.log.verbose('Waiting for account deployment to settle');
@@ -166,6 +190,104 @@ export class BotFactory {
     }
   }
 
+  /**
+   * 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(
+    wallet: AccountWallet,
+    contractAddressSalt: Fr,
+    name: string,
+    ticker: string,
+    decimals = 18,
+  ): Promise<TokenContract> {
+    const deployOpts: DeployOptions = { contractAddressSalt, universalDeploy: true };
+    const deploy = TokenContract.deploy(wallet, wallet.getAddress(), name, ticker, decimals);
+    return this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+  }
+
+  private async setupAmmContract(
+    wallet: AccountWallet,
+    contractAddressSalt: Fr,
+    token0: TokenContract,
+    token1: TokenContract,
+    lpToken: TokenContract,
+  ): Promise<AMMContract> {
+    const deployOpts: DeployOptions = { contractAddressSalt, universalDeploy: true };
+    const deploy = AMMContract.deploy(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();
+    this.log.info(`Set LP token minter to AMM txHash=${await minterTx.getTxHash()}`);
+    await minterTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Liquidity token initialized`);
+
+    return amm;
+  }
+
+  private async fundAmm(
+    wallet: AccountWallet,
+    amm: AMMContract,
+    token0: TokenContract,
+    token1: TokenContract,
+  ): Promise<void> {
+    const nonce = 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 token0Authwit = await wallet.createAuthWit({
+      caller: amm.address,
+      action: token0.methods.transfer_to_public(wallet.getAddress(), amm.address, amount0Max, nonce),
+    });
+    const token1Authwit = await wallet.createAuthWit({
+      caller: amm.address,
+      action: token1.methods.transfer_to_public(wallet.getAddress(), amm.address, amount1Max, nonce),
+    });
+
+    this.log.info(`Minting tokens`);
+    const mintTx = new BatchCall(wallet, [
+      token0.methods.mint_to_private(wallet.getAddress(), wallet.getAddress(), MINT_BALANCE),
+      token1.methods.mint_to_private(wallet.getAddress(), wallet.getAddress(), MINT_BALANCE),
+    ]).send();
+
+    this.log.info(`Sent mint tx: ${await mintTx.getTxHash()}`);
+    await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
+
+    this.log.info(`Funding AMM`);
+    const addLiquidityTx = amm.methods.add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, nonce).send({
+      authWitnesses: [token0Authwit, token1Authwit],
+    });
+
+    this.log.info(`Sent tx to add liquidity to the AMM: ${await addLiquidityTx.getTxHash()}`);
+    await addLiquidityTx.wait({ timeout: this.config.txMinedWaitSeconds });
+  }
+
+  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.pxe.getContractMetadata(address)).isContractPubliclyDeployed) {
+      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 tx with hash ${txHash.toString()}`);
+      await this.tryFlushTxs();
+      this.log.verbose(`Waiting for contract ${name} 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.
@@ -209,7 +331,7 @@ export class BotFactory {
     await sentTx.wait({ timeout: this.config.txMinedWaitSeconds });
   }
 
-  private async bridgeL1FeeJuice(recipient: AztecAddress, amount: bigint) {
+  private async bridgeL1FeeJuice(recipient: AztecAddress) {
     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.');
@@ -226,12 +348,13 @@ export class BotFactory {
     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 mintAmount = await portal.getTokenManager().getMintAmount();
+    const claim = await portal.bridgeTokensPublic(recipient, mintAmount, 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);
+    this.log.info(`Created a claim for ${mintAmount} 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();
@@ -250,7 +373,7 @@ export class BotFactory {
     if (this.config.flushSetupTransactions) {
       this.log.verbose('Flushing transactions');
       try {
-        await this.node!.flushTxs();
+        await this.nodeAdmin!.flushTxs();
       } catch (err) {
         this.log.error(`Failed to flush transactions: ${err}`);
       }

package/src/index.ts

@@ -1,4 +1,5 @@
 export { Bot } from './bot.js';
+export { AmmBot } from './amm_bot.js';
 export { BotRunner } from './runner.js';
 export {
   type BotConfig,

package/src/runner.ts

@@ -1,16 +1,20 @@
 import { type AztecNode, type PXE, createAztecNodeClient, createLogger } from '@aztec/aztec.js';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type AztecNodeAdmin, createAztecNodeAdminClient } from '@aztec/stdlib/interfaces/client';
 import { type TelemetryClient, type Traceable, type Tracer, makeTracedFetch, trackSpan } from '@aztec/telemetry-client';
 
+import { AmmBot } from './amm_bot.js';
+import type { BaseBot } from './base_bot.js';
 import { Bot } from './bot.js';
 import { type BotConfig, getVersions } from './config.js';
 import type { BotRunnerApi } from './interface.js';
 
 export class BotRunner implements BotRunnerApi, Traceable {
   private log = createLogger('bot');
-  private bot?: Promise<Bot>;
+  private bot?: Promise<BaseBot>;
   private pxe?: PXE;
   private node: AztecNode;
+  private nodeAdmin?: AztecNodeAdmin;
   private runningPromise: RunningPromise;
   private consecutiveErrors = 0;
   private healthy = true;
@@ -19,15 +23,19 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   public constructor(
     private config: BotConfig,
-    dependencies: { pxe?: PXE; node?: AztecNode; telemetry: TelemetryClient },
+    dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin; telemetry: TelemetryClient },
   ) {
     this.tracer = dependencies.telemetry.getTracer('Bot');
     this.pxe = dependencies.pxe;
     if (!dependencies.node && !config.nodeUrl) {
       throw new Error(`Missing node URL in config or dependencies`);
     }
-    this.node =
-      dependencies.node ?? createAztecNodeClient(config.nodeUrl!, getVersions(), makeTracedFetch([1, 2, 3], true));
+    const versions = getVersions();
+    const fetch = makeTracedFetch([1, 2, 3], true);
+    this.node = dependencies.node ?? createAztecNodeClient(config.nodeUrl!, versions, fetch);
+    this.nodeAdmin =
+      dependencies.nodeAdmin ??
+      (config.nodeAdminUrl ? createAztecNodeAdminClient(config.nodeAdminUrl, versions, fetch) : undefined);
     this.runningPromise = new RunningPromise(() => this.#work(), this.log, config.txIntervalSeconds * 1000);
   }
 
@@ -131,7 +139,9 @@ export class BotRunner implements BotRunnerApi, Traceable {
 
   async #createBot() {
     try {
-      this.bot = Bot.create(this.config, { pxe: this.pxe, node: this.node });
+      this.bot = this.config.ammTxs
+        ? AmmBot.create(this.config, { pxe: this.pxe, node: this.node, nodeAdmin: this.nodeAdmin })
+        : Bot.create(this.config, { pxe: this.pxe, node: this.node, nodeAdmin: this.nodeAdmin });
       await this.bot;
     } catch (err) {
       this.log.error(`Error setting up bot: ${err}`);

package/src/utils.ts

@@ -1,3 +1,5 @@
+import type { ContractBase } from '@aztec/aztec.js';
+import type { AMMContract } from '@aztec/noir-contracts.js/AMM';
 import type { EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
 import type { TokenContract } from '@aztec/noir-contracts.js/Token';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -22,6 +24,10 @@ export async function getPrivateBalance(token: EasyPrivateTokenContract, who: Az
   return privateBalance;
 }
 
-export function isStandardTokenContract(token: TokenContract | EasyPrivateTokenContract): token is TokenContract {
+export function isStandardTokenContract(token: ContractBase): token is TokenContract {
   return 'mint_to_public' in token.methods;
 }
+
+export function isAMMContract(contract: ContractBase): contract is AMMContract {
+  return 'add_liquidity' in contract.methods;
+}