@aztec/bot 0.76.4 → 0.77.0-testnet-ignition.21

package/src/factory.ts

@@ -1,16 +1,25 @@
 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 { type AztecNode, type FunctionCall, type PXE } from '@aztec/circuit-types';
-import { Fr, deriveSigningKey } from '@aztec/circuits.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';
@@ -28,6 +37,11 @@ export class BotFactory {
     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`);
     }
@@ -60,27 +74,53 @@ export class BotFactory {
    * @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(this.config.senderPrivateKey);
-    const account = await getSchnorrAccount(this.pxe, this.config.senderPrivateKey, signingKey, salt);
+    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 {
-      this.log.info(`Initializing account at ${account.getAddress().toString()}`);
-      const sentTx = account.deploy();
+      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()}`);
-      if (this.config.flushSetupTransactions) {
-        this.log.verbose('Flushing transactions');
-        await this.node!.flushTxs();
-      }
+      await this.tryFlushTxs();
       this.log.verbose('Waiting for account deployment to settle');
       await sentTx.wait({ timeout: this.config.txMinedWaitSeconds });
-      return account.getWallet();
+      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;
   }
 
   /**
@@ -120,10 +160,7 @@ export class BotFactory {
       const sentTx = deploy.send(deployOpts);
       const txHash = await sentTx.getTxHash();
       this.log.info(`Sent tx with hash ${txHash.toString()}`);
-      if (this.config.flushSetupTransactions) {
-        this.log.verbose('Flushing transactions');
-        await this.node!.flushTxs();
-      }
+      await this.tryFlushTxs();
       this.log.verbose('Waiting for token setup to settle');
       return sentTx.deployed({ timeout: this.config.txMinedWaitSeconds });
     }
@@ -149,7 +186,7 @@ export class BotFactory {
     if (privateBalance < MIN_BALANCE) {
       this.log.info(`Minting private tokens for ${sender.toString()}`);
 
-      const from = sender; // we are setting from to sender here because of TODO(#9887)
+      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()
@@ -167,11 +204,56 @@ export class BotFactory {
     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');
-      await this.node!.flushTxs();
+      try {
+        await this.node!.flushTxs();
+      } catch (err) {
+        this.log.error(`Failed to flush transactions: ${err}`);
+      }
     }
-    this.log.verbose('Waiting for token mint to settle');
-    await sentTx.wait({ timeout: this.config.txMinedWaitSeconds });
   }
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 export { Bot } from './bot.js';
 export { BotRunner } from './runner.js';
 export {
-  BotConfig,
+  type BotConfig,
   getBotConfigFromEnv,
   getBotDefaultConfig,
   botConfigMappings,

package/src/interface.ts

@@ -1,4 +1,4 @@
-import { type ApiSchemaFor } from '@aztec/foundation/schemas';
+import type { ApiSchemaFor } from '@aztec/stdlib/schemas';
 
 import { z } from 'zod';
 

package/src/rpc.ts

@@ -1,8 +1,8 @@
-import { type ApiHandler } from '@aztec/foundation/json-rpc/server';
+import type { ApiHandler } from '@aztec/foundation/json-rpc/server';
 import { createTracedJsonRpcServer } from '@aztec/telemetry-client';
 
 import { BotRunnerApiSchema } from './interface.js';
-import { type BotRunner } from './runner.js';
+import type { BotRunner } from './runner.js';
 
 /**
  * Wraps a bot runner with a JSON RPC HTTP server.

package/src/runner.ts

@@ -4,7 +4,7 @@ import { type TelemetryClient, type Traceable, type Tracer, makeTracedFetch, tra
 
 import { Bot } from './bot.js';
 import { type BotConfig, getVersions } from './config.js';
-import { type BotRunnerApi } from './interface.js';
+import type { BotRunnerApi } from './interface.js';
 
 export class BotRunner implements BotRunnerApi, Traceable {
   private log = createLogger('bot');

package/src/utils.ts

@@ -1,6 +1,6 @@
-import { type AztecAddress } from '@aztec/circuits.js';
-import { type EasyPrivateTokenContract } from '@aztec/noir-contracts.js/EasyPrivateToken';
-import { type TokenContract } from '@aztec/noir-contracts.js/Token';
+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';
 
 /**
  * Gets the private and public balance of the given token for the given address.