@aztec/bot 0.0.1-commit.d3ec352c → 0.0.1-commit.d6f2b3f94

package/src/config.ts

@@ -10,11 +10,11 @@ import {
   secretFrConfigHelper,
   secretStringConfigHelper,
 } from '@aztec/foundation/config';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
-import { type ZodFor, schemas } from '@aztec/stdlib/schemas';
+import { schemas, zodFor } from '@aztec/stdlib/schemas';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
 import { z } from 'zod';
@@ -54,8 +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;
+  /** 'How much is the bot willing to overpay vs. the current min fee' */
+  minFeePadding: number;
   /** True to not automatically setup or start the bot on initialization. */
   noStart: boolean;
   /** How long to wait for a tx to be mined before reporting an error. */
@@ -80,50 +80,52 @@ export type BotConfig = {
   ammTxs: boolean;
 } & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'>;
 
-export const BotConfigSchema = z
-  .object({
-    nodeUrl: z.string().optional(),
-    nodeAdminUrl: z.string().optional(),
-    l1RpcUrls: z.array(z.string()).optional(),
-    l1Mnemonic: schemas.SecretValue(z.string()).optional(),
-    l1PrivateKey: schemas.SecretValue(z.string()).optional(),
-    l1ToL2MessageTimeoutSeconds: z.number(),
-    senderPrivateKey: schemas.SecretValue(schemas.Fr).optional(),
-    senderSalt: schemas.Fr.optional(),
-    tokenSalt: schemas.Fr,
-    txIntervalSeconds: z.number(),
-    privateTransfersPerTx: z.number().int().nonnegative(),
-    publicTransfersPerTx: z.number().int().nonnegative(),
-    feePaymentMethod: z.literal('fee_juice'),
-    baseFeePadding: z.number().int().nonnegative(),
-    noStart: z.boolean(),
-    txMinedWaitSeconds: z.number(),
-    followChain: z.enum(BotFollowChain),
-    maxPendingTxs: z.number().int().nonnegative(),
-    flushSetupTransactions: z.boolean(),
-    l2GasLimit: z.number().int().nonnegative().optional(),
-    daGasLimit: z.number().int().nonnegative().optional(),
-    contract: z.nativeEnum(SupportedTokenContracts),
-    maxConsecutiveErrors: z.number().int().nonnegative(),
-    stopWhenUnhealthy: z.boolean(),
-    ammTxs: z.boolean().default(false),
-    dataDirectory: z.string().optional(),
-    dataStoreMapSizeKb: z.number().optional(),
-  })
-  .transform(config => ({
-    nodeUrl: undefined,
-    nodeAdminUrl: undefined,
-    l1RpcUrls: undefined,
-    senderSalt: undefined,
-    l2GasLimit: undefined,
-    daGasLimit: undefined,
-    l1Mnemonic: undefined,
-    l1PrivateKey: undefined,
-    senderPrivateKey: undefined,
-    dataDirectory: undefined,
-    dataStoreMapSizeKb: 1_024 * 1_024,
-    ...config,
-  })) satisfies ZodFor<BotConfig>;
+export const BotConfigSchema = zodFor<BotConfig>()(
+  z
+    .object({
+      nodeUrl: z.string().optional(),
+      nodeAdminUrl: z.string().optional(),
+      l1RpcUrls: z.array(z.string()).optional(),
+      l1Mnemonic: schemas.SecretValue(z.string()).optional(),
+      l1PrivateKey: schemas.SecretValue(z.string()).optional(),
+      l1ToL2MessageTimeoutSeconds: z.number(),
+      senderPrivateKey: schemas.SecretValue(schemas.Fr).optional(),
+      senderSalt: schemas.Fr.optional(),
+      tokenSalt: schemas.Fr,
+      txIntervalSeconds: z.number(),
+      privateTransfersPerTx: z.number().int().nonnegative(),
+      publicTransfersPerTx: z.number().int().nonnegative(),
+      feePaymentMethod: z.literal('fee_juice'),
+      minFeePadding: z.number().int().nonnegative(),
+      noStart: z.boolean(),
+      txMinedWaitSeconds: z.number(),
+      followChain: z.enum(BotFollowChain),
+      maxPendingTxs: z.number().int().nonnegative(),
+      flushSetupTransactions: z.boolean(),
+      l2GasLimit: z.number().int().nonnegative().optional(),
+      daGasLimit: z.number().int().nonnegative().optional(),
+      contract: z.nativeEnum(SupportedTokenContracts),
+      maxConsecutiveErrors: z.number().int().nonnegative(),
+      stopWhenUnhealthy: z.boolean(),
+      ammTxs: z.boolean().default(false),
+      dataDirectory: z.string().optional(),
+      dataStoreMapSizeKb: z.number().optional(),
+    })
+    .transform(config => ({
+      nodeUrl: undefined,
+      nodeAdminUrl: undefined,
+      l1RpcUrls: undefined,
+      senderSalt: undefined,
+      l2GasLimit: undefined,
+      daGasLimit: undefined,
+      l1Mnemonic: undefined,
+      l1PrivateKey: undefined,
+      senderPrivateKey: undefined,
+      dataDirectory: undefined,
+      dataStoreMapSizeKb: 1_024 * 1_024,
+      ...config,
+    })),
+);
 
 export const botConfigMappings: ConfigMappingsType<BotConfig> = {
   nodeUrl: {
@@ -191,8 +193,8 @@ export const botConfigMappings: ConfigMappingsType<BotConfig> = {
     parseEnv: val => (val as 'fee_juice') || undefined,
     defaultValue: 'fee_juice',
   },
-  baseFeePadding: {
-    env: 'BOT_BASE_FEE_PADDING',
+  minFeePadding: {
+    env: 'BOT_MIN_FEE_PADDING',
     description: 'How much is the bot willing to overpay vs. the current base fee',
     ...numberConfigHelper(3),
   },

package/src/factory.ts

@@ -7,18 +7,23 @@ import {
   ContractFunctionInteraction,
   type DeployMethod,
   type DeployOptions,
+  NO_WAIT,
 } 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, createExtendedL1Client } from '@aztec/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { waitForTx } from '@aztec/aztec.js/node';
+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 { 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';
@@ -53,8 +58,8 @@ export class BotFactory {
     node: AztecNode;
     recipient: AztecAddress;
   }> {
-    const recipient = (await this.wallet.createAccount()).address;
     const defaultAccountAddress = await this.setupAccount();
+    const recipient = (await this.wallet.createAccount()).address;
     const token = await this.setupToken(defaultAccountAddress);
     await this.mintTokens(token, defaultAccountAddress);
     return { wallet: this.wallet, defaultAccountAddress, token, node: this.aztecNode, recipient };
@@ -115,8 +120,8 @@ export class BotFactory {
       contract: new SchnorrAccountContract(signingKey!),
     };
     const accountManager = await this.wallet.createAccount(accountData);
-    const isInit = (await this.wallet.getContractMetadata(accountManager.address)).isContractInitialized;
-    if (isInit) {
+    const metadata = await this.wallet.getContractMetadata(accountManager.address);
+    if (metadata.isContractInitialized) {
       this.log.info(`Account at ${accountManager.address.toString()} already initialized`);
       const timer = new Timer();
       const address = accountManager.address;
@@ -131,12 +136,18 @@ export class BotFactory {
 
       const paymentMethod = new FeeJuicePaymentMethodWithClaim(accountManager.address, claim);
       const deployMethod = await accountManager.getDeployMethod();
-      const maxFeesPerGas = (await this.aztecNode.getCurrentBaseFees()).mul(1 + this.config.baseFeePadding);
+      const maxFeesPerGas = (await this.aztecNode.getCurrentMinFees()).mul(1 + this.config.minFeePadding);
       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 for account deployment with hash ${txHash.toString()}`);
-      await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
+
+      await this.withNoMinTxsPerBlock(async () => {
+        const txHash = await deployMethod.send({
+          from: AztecAddress.ZERO,
+          fee: { gasSettings, paymentMethod },
+          wait: NO_WAIT,
+        });
+        this.log.info(`Sent tx for account deployment with hash ${txHash.toString()}`);
+        return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+      });
       this.log.info(`Account deployed at ${address}`);
 
       // Clean up the consumed bridge claim
@@ -164,33 +175,49 @@ export class BotFactory {
    */
   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,
     };
+    let token: TokenContract | PrivateTokenContract;
     if (this.config.contract === SupportedTokenContracts.TokenContract) {
       deploy = TokenContract.deploy(this.wallet, sender, 'BotToken', 'BOT', 18);
+      tokenInstance = await deploy.getInstance(deployOpts);
+      token = TokenContract.at(tokenInstance.address, this.wallet);
     } else if (this.config.contract === SupportedTokenContracts.PrivateTokenContract) {
-      deploy = PrivateTokenContract.deploy(this.wallet, MINT_BALANCE, sender);
+      // 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;
+
+      // Register the contract with the secret key before deployment
+      tokenInstance = await deploy.getInstance(deployOpts);
+      token = PrivateTokenContract.at(tokenInstance.address, this.wallet);
+      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.wallet.getContractMetadata(address)).isContractPublished) {
+    const address = tokenInstance?.address ?? (await deploy.getInstance(deployOpts)).address;
+    const metadata = await this.wallet.getContractMetadata(address);
+    if (metadata.isContractPublished) {
       this.log.info(`Token at ${address.toString()} already deployed`);
-      return deploy.register();
+      await deploy.register();
     } else {
       this.log.info(`Deploying token contract at ${address.toString()}`);
-      const sentTx = deploy.send(deployOpts);
-      const txHash = await sentTx.getTxHash();
+      const txHash = await deploy.send({ ...deployOpts, wait: NO_WAIT });
       this.log.info(`Sent tx for token setup with hash ${txHash.toString()}`);
-      return this.withNoMinTxsPerBlock(() => sentTx.deployed({ timeout: this.config.txMinedWaitSeconds }));
+      await this.withNoMinTxsPerBlock(async () => {
+        await waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+        return token;
+      });
     }
+    return token;
   }
 
   /**
@@ -198,7 +225,7 @@ export class BotFactory {
    * @param wallet - Wallet to deploy the token contract from.
    * @returns The TokenContract instance.
    */
-  private setupTokenContract(
+  private async setupTokenContract(
     deployer: AztecAddress,
     contractAddressSalt: Fr,
     name: string,
@@ -207,7 +234,8 @@ export class BotFactory {
   ): 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);
+    const instance = await this.registerOrDeployContract('Token - ' + name, deploy, deployOpts);
+    return TokenContract.at(instance.address, this.wallet);
   }
 
   private async setupAmmContract(
@@ -219,12 +247,14 @@ export class BotFactory {
   ): 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);
+    const instance = await this.registerOrDeployContract('AMM', deploy, deployOpts);
+    const amm = AMMContract.at(instance.address, this.wallet);
 
     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 });
+    const minterReceipt = await lpToken.methods
+      .set_minter(amm.address, true)
+      .send({ from: deployer, wait: { timeout: this.config.txMinedWaitSeconds } });
+    this.log.info(`Set LP token minter to AMM txHash=${minterReceipt.txHash.toString()}`);
     this.log.info(`Liquidity token initialized`);
 
     return amm;
@@ -283,23 +313,22 @@ export class BotFactory {
         .getFunctionCall(),
     });
 
-    const mintTx = new BatchCall(this.wallet, [
+    const mintReceipt = await new BatchCall(this.wallet, [
       token0.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
       token1.methods.mint_to_private(liquidityProvider, MINT_BALANCE),
-    ]).send({ from: liquidityProvider });
+    ]).send({ from: liquidityProvider, wait: { timeout: this.config.txMinedWaitSeconds } });
 
-    this.log.info(`Sent mint tx: ${(await mintTx.getTxHash()).toString()}`);
-    await mintTx.wait({ timeout: this.config.txMinedWaitSeconds });
+    this.log.info(`Sent mint tx: ${mintReceipt.txHash.toString()}`);
 
-    const addLiquidityTx = amm.methods
+    const addLiquidityReceipt = await amm.methods
       .add_liquidity(amount0Max, amount1Max, amount0Min, amount1Min, authwitNonce)
       .send({
         from: liquidityProvider,
         authWitnesses: [token0Authwit, token1Authwit],
+        wait: { timeout: this.config.txMinedWaitSeconds },
       });
 
-    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(`Sent tx to add liquidity to the AMM: ${addLiquidityReceipt.txHash.toString()}`);
     this.log.info(`Liquidity added`);
 
     const [newT0Bal, newT1Bal, newLPBal] = await getPrivateBalances();
@@ -312,18 +341,22 @@ export class BotFactory {
     name: string,
     deploy: DeployMethod<T>,
     deployOpts: DeployOptions,
-  ): Promise<T> {
-    const address = (await deploy.getInstance(deployOpts)).address;
-    if ((await this.wallet.getContractMetadata(address)).isContractPublished) {
+  ): Promise<ContractInstanceWithAddress> {
+    const instance = await deploy.getInstance(deployOpts);
+    const address = instance.address;
+    const metadata = await this.wallet.getContractMetadata(address);
+    if (metadata.isContractPublished) {
       this.log.info(`Contract ${name} at ${address.toString()} already deployed`);
-      return deploy.register();
+      await 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 }));
+      await this.withNoMinTxsPerBlock(async () => {
+        const txHash = await deploy.send({ ...deployOpts, wait: NO_WAIT });
+        this.log.info(`Sent contract ${name} setup tx with hash ${txHash.toString()}`);
+        return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+      });
     }
+    return instance;
   }
 
   /**
@@ -359,10 +392,12 @@ export class BotFactory {
       this.log.info(`Skipping minting as ${minter.toString()} has enough tokens`);
       return;
     }
-    const sentTx = new BatchCall(token.wallet, calls).send({ from: minter });
-    const txHash = await sentTx.getTxHash();
-    this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
-    await this.withNoMinTxsPerBlock(() => sentTx.wait({ timeout: this.config.txMinedWaitSeconds }));
+
+    await this.withNoMinTxsPerBlock(async () => {
+      const txHash = await new BatchCall(token.wallet, calls).send({ from: minter, wait: NO_WAIT });
+      this.log.info(`Sent token mint tx with hash ${txHash.toString()}`);
+      return waitForTx(this.aztecNode, txHash, { timeout: this.config.txMinedWaitSeconds });
+    });
   }
 
   /**

package/src/store/bot_store.ts

@@ -1,6 +1,6 @@
 import { AztecAddress } from '@aztec/aztec.js/addresses';
 import type { L2AmountClaim } from '@aztec/aztec.js/ethereum';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';