refactor!: nuking Aztec Node proxy methods from PXE (#17098)

Having these methods exposed on PXE is a relic of a past. PXE JSON RPC
server will soon be nuked and we will no longer pass a PXE_URL around
and we will just pass NODE_URL.

Note that in some places this results in a worse devex as now it's
necessary to pass on the input both AZTEC_NODE_URL and PXE_URL. This is
only temporary so would not worry about this.

## Follow-up work
In this PR I don't touch the `PXE` proxy methods that were exposed on
`Wallet` as well as it's not yet resolved what to do with those.

I also didn't yet touch `getCurrentBaseFees` as that is used by `Wallet`
implementations and that would then force me to pass `AztecNode` on the
input of those implementations which is a huge change. For this reason
plan on doing that in a PR up the stack.

Author: benesjan

yarn-project/aztec.js/src/contract/wait_for_proven.ts

@@ -1,5 +1,5 @@
 import { retryUntil } from '@aztec/foundation/retry';
-import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 import type { TxReceipt } from '../index.js';
 import { DefaultWaitOpts } from './sent_tx.js';
@@ -22,13 +22,13 @@ export const DefaultWaitForProvenOpts: WaitForProvenOpts = {
 /**
  * Wait for a transaction to be proven by polling the node
  */
-export async function waitForProven(pxeOrNode: PXE | AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
+export async function waitForProven(node: AztecNode, receipt: TxReceipt, opts?: WaitForProvenOpts) {
   if (!receipt.blockNumber) {
     throw new Error(`Cannot wait for proven: receipt of tx ${receipt.txHash} does not have a block number`);
   }
   return await retryUntil(
     async () => {
-      const provenBlock = await pxeOrNode.getProvenBlockNumber();
+      const provenBlock = await node.getProvenBlockNumber();
       return provenBlock >= receipt.blockNumber! ? provenBlock : undefined;
     },
     'isProven',

yarn-project/aztec.js/src/utils/cross_chain.ts

@@ -1,25 +1,24 @@
 import type { Fr } from '@aztec/foundation/fields';
 import { retryUntil } from '@aztec/foundation/retry';
-
-import type { PXE } from '../api/interfaces.js';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 /**
  * Waits for the L1 to L2 message to be ready to be consumed.
- * @param pxe - PXE instance
+ * @param node - Aztec node instance used to obtain the information about the message
  * @param l1ToL2MessageHash - Hash of the L1 to L2 message
  * @param opts - Options
  */
 export async function waitForL1ToL2MessageReady(
-  pxe: Pick<PXE, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
   l1ToL2MessageHash: Fr,
   opts: {
     /** Timeout for the operation in seconds */ timeoutSeconds: number;
     /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
   },
 ) {
-  const messageBlockNumber = await pxe.getL1ToL2MessageBlock(l1ToL2MessageHash);
+  const messageBlockNumber = await node.getL1ToL2MessageBlock(l1ToL2MessageHash);
   return retryUntil(
-    () => isL1ToL2MessageReady(pxe, l1ToL2MessageHash, { ...opts, messageBlockNumber }),
+    () => isL1ToL2MessageReady(node, l1ToL2MessageHash, { ...opts, messageBlockNumber }),
     `L1 to L2 message ${l1ToL2MessageHash.toString()} ready`,
     opts.timeoutSeconds,
     1,
@@ -28,21 +27,21 @@ export async function waitForL1ToL2MessageReady(
 
 /**
  * Returns whether the L1 to L2 message is ready to be consumed.
- * @param pxe - PXE instance
+ * @param node - Aztec node instance used to obtain the information about the message
  * @param l1ToL2MessageHash - Hash of the L1 to L2 message
  * @param opts - Options
  * @returns True if the message is ready to be consumed, false otherwise
  */
 export async function isL1ToL2MessageReady(
-  pxe: Pick<PXE, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
+  node: Pick<AztecNode, 'getBlockNumber' | 'getL1ToL2MessageBlock'>,
   l1ToL2MessageHash: Fr,
   opts: {
     /** True if the message is meant to be consumed from a public function */ forPublicConsumption: boolean;
     /** Cached synced block number for the message (will be fetched from PXE otherwise) */ messageBlockNumber?: number;
   },
 ): Promise<boolean> {
-  const blockNumber = await pxe.getBlockNumber();
-  const messageBlockNumber = opts.messageBlockNumber ?? (await pxe.getL1ToL2MessageBlock(l1ToL2MessageHash));
+  const blockNumber = await node.getBlockNumber();
+  const messageBlockNumber = opts.messageBlockNumber ?? (await node.getL1ToL2MessageBlock(l1ToL2MessageHash));
   if (messageBlockNumber === undefined) {
     return false;
   }

yarn-project/aztec.js/src/utils/fee_juice.ts

@@ -2,12 +2,13 @@ import { Fr } from '@aztec/foundation/fields';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 /**
  * Returns the owner's fee juice balance.
+ * Note: This is used only e2e_sandbox_example test. TODO: Consider nuking.
  */
-export async function getFeeJuiceBalance(owner: AztecAddress, pxe: PXE): Promise<bigint> {
+export async function getFeeJuiceBalance(owner: AztecAddress, node: AztecNode): Promise<bigint> {
   const slot = await deriveStorageSlotInMap(new Fr(1), owner);
-  return (await pxe.getPublicStorageAt(ProtocolContractAddress.FeeJuice, slot)).toBigInt();
+  return (await node.getPublicStorageAt('latest', ProtocolContractAddress.FeeJuice, slot)).toBigInt();
 }

yarn-project/aztec/src/bin/index.ts

@@ -2,6 +2,7 @@
 //
 import { injectCommands as injectBuilderCommands } from '@aztec/builder';
 import { injectCommands as injectWalletCommands } from '@aztec/cli-wallet';
+import { injectCommands as injectAztecNodeCommands } from '@aztec/cli/aztec_node';
 import { enrichEnvironmentWithChainConfig } from '@aztec/cli/config';
 import { injectCommands as injectContractCommands } from '@aztec/cli/contracts';
 import { injectCommands as injectDevnetCommands } from '@aztec/cli/devnet';
@@ -50,6 +51,7 @@ async function main() {
   program = injectInfrastructureCommands(program, userLog, debugLogger);
   program = injectL1Commands(program, userLog, debugLogger);
   program = injectPXECommands(program, userLog, debugLogger);
+  program = injectAztecNodeCommands(program, userLog, debugLogger);
   program = injectMiscCommands(program, userLog);
   program = injectDevnetCommands(program, userLog, debugLogger);
   program = injectWalletCommands(program, userLog, debugLogger);

yarn-project/aztec/src/testing/aztec_cheat_codes.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { deriveStorageSlotInMap } from '@aztec/stdlib/hash';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode, PXE } from '@aztec/stdlib/interfaces/client';
 import type { Note } from '@aztec/stdlib/note';
 
 /**
@@ -14,6 +14,10 @@ export class AztecCheatCodes {
      * The PXE Service to use for interacting with the chain
      */
     public pxe: PXE,
+    /**
+     * The Aztec Node to use for interacting with the chain
+     */
+    public node: AztecNode,
     /**
      * The logger to use for the aztec cheatcodes
      */
@@ -36,15 +40,15 @@ export class AztecCheatCodes {
    * @returns The current block number
    */
   public async blockNumber(): Promise<number> {
-    return await this.pxe.getBlockNumber();
+    return await this.node.getBlockNumber();
   }
 
   /**
    * Get the current timestamp
    * @returns The current timestamp
    */
   public async timestamp(): Promise<number> {
-    const res = await this.pxe.getBlock(await this.blockNumber());
+    const res = await this.node.getBlock(await this.blockNumber());
     return Number(res?.header.globalVariables.timestamp ?? 0);
   }
 
@@ -55,7 +59,7 @@ export class AztecCheatCodes {
    * @returns The value stored at the given slot
    */
   public async loadPublic(who: AztecAddress, slot: Fr | bigint): Promise<Fr> {
-    const storageValue = await this.pxe.getPublicStorageAt(who, new Fr(slot));
+    const storageValue = await this.node.getPublicStorageAt('latest', who, new Fr(slot));
     return storageValue;
   }
 

yarn-project/aztec/src/testing/cheat_codes.ts

@@ -18,9 +18,9 @@ export class CheatCodes {
     public rollup: RollupCheatCodes,
   ) {}
 
-  static async create(rpcUrls: string[], pxe: PXE): Promise<CheatCodes> {
+  static async create(rpcUrls: string[], pxe: PXE, node: AztecNode): Promise<CheatCodes> {
     const ethCheatCodes = new EthCheatCodes(rpcUrls);
-    const aztecCheatCodes = new AztecCheatCodes(pxe);
+    const aztecCheatCodes = new AztecCheatCodes(pxe, node);
     const rollupCheatCodes = new RollupCheatCodes(
       ethCheatCodes,
       await pxe.getNodeInfo().then(n => n.l1ContractAddresses),

yarn-project/bot/src/amm_bot.ts

@@ -15,26 +15,26 @@ type Balances = { token0: bigint; token1: bigint };
 
 export class AmmBot extends BaseBot {
   protected constructor(
-    pxe: PXE,
+    node: AztecNode,
     wallet: Wallet,
     defaultAccountAddress: AztecAddress,
     public readonly amm: AMMContract,
     public readonly token0: TokenContract,
     public readonly token1: TokenContract,
     config: BotConfig,
   ) {
-    super(pxe, wallet, defaultAccountAddress, config);
+    super(node, wallet, defaultAccountAddress, config);
   }
 
   static async create(
     config: BotConfig,
     dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin },
   ): Promise<AmmBot> {
-    const { pxe, wallet, defaultAccountAddress, token0, token1, amm } = await new BotFactory(
+    const { node, wallet, defaultAccountAddress, token0, token1, amm } = await new BotFactory(
       config,
       dependencies,
     ).setupAmm();
-    return new AmmBot(pxe, wallet, defaultAccountAddress, amm, token0, token1, config);
+    return new AmmBot(node, wallet, defaultAccountAddress, amm, token0, token1, config);
   }
 
   protected async createAndSendTx(logCtx: object): Promise<SentTx> {

yarn-project/bot/src/base_bot.ts

@@ -11,7 +11,7 @@ import {
   waitForProven,
 } from '@aztec/aztec.js';
 import { Gas } from '@aztec/stdlib/gas';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 
 import type { BotConfig } from './config.js';
 
@@ -22,7 +22,7 @@ export abstract class BaseBot {
   protected successes: number = 0;
 
   protected constructor(
-    public readonly pxe: PXE,
+    public readonly node: AztecNode,
     public readonly wallet: Wallet,
     public readonly defaultAccountAddress: AztecAddress,
     public config: BotConfig,
@@ -51,7 +51,7 @@ export abstract class BaseBot {
       timeout: txMinedWaitSeconds,
     });
     if (followChain === 'PROVEN') {
-      await waitForProven(this.pxe, receipt, { provenTimeout: txMinedWaitSeconds });
+      await waitForProven(this.node, receipt, { provenTimeout: txMinedWaitSeconds });
     }
     this.successes++;
     this.log.info(

yarn-project/bot/src/bot.ts

@@ -13,22 +13,25 @@ const TRANSFER_AMOUNT = 1;
 
 export class Bot extends BaseBot {
   protected constructor(
-    pxe: PXE,
+    node: AztecNode,
     wallet: Wallet,
     defaultAccountAddress: AztecAddress,
     public readonly token: TokenContract | PrivateTokenContract,
     public readonly recipient: AztecAddress,
     config: BotConfig,
   ) {
-    super(pxe, wallet, defaultAccountAddress, config);
+    super(node, wallet, defaultAccountAddress, config);
   }
 
   static async create(
     config: BotConfig,
     dependencies: { pxe?: PXE; node?: AztecNode; nodeAdmin?: AztecNodeAdmin },
   ): Promise<Bot> {
-    const { pxe, wallet, defaultAccountAddress, token, recipient } = await new BotFactory(config, dependencies).setup();
-    return new Bot(pxe, wallet, defaultAccountAddress, token, recipient, config);
+    const { node, wallet, defaultAccountAddress, token, recipient } = await new BotFactory(
+      config,
+      dependencies,
+    ).setup();
+    return new Bot(node, wallet, defaultAccountAddress, token, recipient, config);
   }
 
   public updateConfig(config: Partial<BotConfig>) {

yarn-project/bot/src/factory.ts

@@ -10,6 +10,7 @@ import {
   FeeJuicePaymentMethodWithClaim,
   L1FeeJuicePortalManager,
   type PXE,
+  createAztecNodeClient,
   createLogger,
   createPXEClient,
   waitForL1ToL2MessageReady,
@@ -34,7 +35,7 @@ const MIN_BALANCE = 1e3;
 export class BotFactory {
   private pxe: PXE;
   private wallet: TestWallet;
-  private node?: AztecNode;
+  private node: AztecNode;
   private nodeAdmin?: AztecNodeAdmin;
   private log = createLogger('bot');
 
@@ -56,7 +57,6 @@ export class BotFactory {
       throw new Error(`Either a PXE client or a PXE URL must be provided`);
     }
 
-    this.node = dependencies.node;
     this.nodeAdmin = dependencies.nodeAdmin;
 
     if (dependencies.pxe) {
@@ -66,6 +66,13 @@ export class BotFactory {
       this.log.info(`Using remote PXE at ${config.pxeUrl!}`);
       this.pxe = createPXEClient(config.pxeUrl!, getVersions(), makeTracedFetch([1, 2, 3], false));
     }
+
+    if (dependencies.node) {
+      this.node = dependencies.node;
+    } else {
+      this.node = createAztecNodeClient(config.nodeUrl!, getVersions(), makeTracedFetch([1, 2, 3], false));
+    }
+
     this.wallet = new TestWallet(this.pxe);
   }
 
@@ -78,7 +85,7 @@ export class BotFactory {
     const defaultAccountAddress = await this.setupAccount();
     const token = await this.setupToken(defaultAccountAddress);
     await this.mintTokens(token, defaultAccountAddress);
-    return { wallet: this.wallet, defaultAccountAddress, token, pxe: this.pxe, recipient };
+    return { wallet: this.wallet, defaultAccountAddress, token, node: this.node, recipient };
   }
 
   public async setupAmm() {
@@ -102,7 +109,7 @@ export class BotFactory {
     await this.fundAmm(defaultAccountAddress, defaultAccountAddress, amm, token0, token1, liquidityToken);
     this.log.info(`AMM initialized and funded`);
 
-    return { wallet: this.wallet, defaultAccountAddress, amm, token0, token1, pxe: this.pxe };
+    return { wallet: this.wallet, defaultAccountAddress, amm, token0, token1, node: this.node };
   }
 
   /**
@@ -398,7 +405,7 @@ export class BotFactory {
     const claim = await portal.bridgeTokensPublic(recipient, mintAmount, true /* mint */);
 
     await this.withNoMinTxsPerBlock(() =>
-      waitForL1ToL2MessageReady(this.pxe, Fr.fromHexString(claim.messageHash), {
+      waitForL1ToL2MessageReady(this.node, Fr.fromHexString(claim.messageHash), {
         timeoutSeconds: this.config.l1ToL2MessageTimeoutSeconds,
         forPublicConsumption: false,
       }),