@aztec/end-to-end 0.0.1-commit.2b2662070 → 0.0.1-commit.2c0ee1788

package/src/fixtures/setup.ts

@@ -17,7 +17,7 @@ import { Fr } from '@aztec/aztec.js/fields';
 import { type Logger, createLogger } from '@aztec/aztec.js/log';
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Wallet } from '@aztec/aztec.js/wallet';
-import { AnvilTestWatcher, CheatCodes } from '@aztec/aztec/testing';
+import { AnvilTestWatcher, type AnvilTestWatcherOpts, CheatCodes } from '@aztec/aztec/testing';
 import { SPONSORED_FPC_SALT } from '@aztec/constants';
 import { isAnvilTestChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
@@ -185,6 +185,7 @@ export type SetupOptions = {
   mockGossipSubNetworkLatency?: number;
   /** Whether to disable the anvil test watcher (can still be manually started) */
   disableAnvilTestWatcher?: boolean;
+  anvilTestWatcherOpts?: AnvilTestWatcherOpts;
   /** Whether to enable anvil automine during deployment of L1 contracts (consider defaulting this to true). */
   automineL1Setup?: boolean;
   /** How many accounts to seed and unlock in anvil. */
@@ -206,8 +207,11 @@ export type SetupOptions = {
   skipAccountDeployment?: boolean;
   /** L1 contracts deployment arguments. */
   l1ContractsArgs?: Partial<DeployAztecL1ContractsArgs>;
-  /** Wallet minimum fee padding multiplier (defaults to 0.5, which is 50% padding). */
+  /** Wallet minimum fee padding multiplier */
   walletMinFeePadding?: number;
+  /** Whether the initial node should be a lightweight RPC-only node (no sequencer, no validator).
+   *  Use for tests that create their own validator nodes and don't need the initial sequencer. */
+  skipInitialSequencer?: boolean;
 } & Partial<AztecNodeConfig>;
 
 /** Context for an end-to-end test as returned by the `setup` function */
@@ -444,6 +448,7 @@ export async function setup(
       deployL1ContractsValues.l1ContractAddresses.rollupAddress,
       deployL1ContractsValues.l1Client,
       dateProvider,
+      opts.anvilTestWatcherOpts,
     );
     if (!opts.disableAnvilTestWatcher) {
       await watcher.start();
@@ -502,8 +507,23 @@ export async function setup(
       }
     }
 
+    // When skipInitialSequencer is set, the initial node is a lightweight RPC-only node.
+    // We apply these overrides to a copy so they don't leak into the returned config.
+    // Keep P2P enabled if mockGossipSubNetwork is used (needed for tx propagation to validators).
+    const initialNodeConfig = opts.skipInitialSequencer
+      ? {
+          ...config,
+          disableValidator: true,
+          ...(opts.mockGossipSubNetwork ? {} : { p2pEnabled: false, bootstrapNodes: [] as string[] }),
+        }
+      : config;
+
     const aztecNodeService = await withLoggerBindings({ actor: 'node-0' }, () =>
-      AztecNodeService.createAndSync(config, { dateProvider, telemetry: telemetryClient, p2pClientDeps }, { genesis }),
+      AztecNodeService.createAndSync(
+        initialNodeConfig,
+        { dateProvider, telemetry: telemetryClient, p2pClientDeps },
+        { genesis, dontStartSequencer: opts.skipInitialSequencer },
+      ),
     );
     const sequencerClient = aztecNodeService.getSequencer();
 
@@ -563,7 +583,9 @@ export async function setup(
 
     let accounts: AztecAddress[] = [];
 
-    if (shouldDeployAccounts) {
+    if (opts.skipInitialSequencer) {
+      logger.info('Sequencer not started on initial node, skipping block progression');
+    } else if (shouldDeployAccounts) {
       logger.info(
         `${numberOfAccounts} accounts are being deployed. Reliably progressing past genesis by setting minTxsPerBlock to 1 and waiting for the accounts to be deployed`,
       );
@@ -712,7 +734,7 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: BlockNum
   targetBlock ??= await node.getBlockNumber();
 
   await retryUntil(
-    async () => (await node.getProvenBlockNumber()) >= targetBlock,
+    async () => (await node.getBlockNumber('proven')) >= targetBlock,
     'proven chain status',
     timeoutSec,
     intervalSec,

package/src/forward-compatibility/wallet_rpc_client.ts

@@ -0,0 +1,14 @@
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+
+/**
+ * Creates a JSON-RPC client that connects to a remote wallet service.
+ * The returned object implements the {@link Wallet} interface, proxying all calls over HTTP to the specified URL.
+ */
+export function createWalletClient(url: string): Wallet {
+  return createSafeJsonRpcClient<Wallet>(url, WalletSchema, {
+    namespaceMethods: 'wallet',
+    fetch: makeFetch([1, 2, 3], false),
+  });
+}

package/src/forward-compatibility/wallet_service.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env -S node --no-warnings
+/**
+ * Standalone entrypoint that spins up a local Aztec network (L1 + node) and exposes a {@link NodeEmbeddedWallet} over
+ * JSON-RPC.
+ *
+ * Intended for forward-compatibility testing: an **old** release image runs this script so that **new** tests can send
+ * new artifacts to old runtime code (loadContractArtifact, ACIR simulator, class-ID computation, entrypoint encoding,
+ * etc.).
+ */
+import { getSchnorrAccountContractAddress } from '@aztec/accounts/schnorr';
+import { getInitialTestAccountsData } from '@aztec/accounts/testing';
+import { createLocalNetwork } from '@aztec/aztec';
+import { Fr } from '@aztec/aztec.js/fields';
+import { WalletSchema } from '@aztec/aztec.js/wallet';
+import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
+import { createNamespacedSafeJsonRpcServer, startHttpRpcServer } from '@aztec/foundation/json-rpc/server';
+import { createLogger } from '@aztec/foundation/log';
+import { AztecNodeApiSchema } from '@aztec/stdlib/interfaces/client';
+import { EmbeddedWallet } from '@aztec/wallets/embedded';
+
+const logger = createLogger('wallet-service');
+
+const { ETHEREUM_HOSTS = 'http://localhost:8545', NODE_PORT = '8080', WALLET_PORT = '8081' } = process.env;
+
+async function main() {
+  const l1RpcUrls = ETHEREUM_HOSTS.split(',').map(url => url.trim());
+
+  // Some tests (e.g. AMM) need 4 accounts but only 3 are funded via genesis. Generate deterministic keys for a 4th
+  // account so we can compute its address before network startup and include it in genesis funding. We cannot do this
+  // in the test because Wallet interface does not expose account creation functionality (only TestWallet exposes that
+  // but that's not used in forward compatibility testing).
+  const extraAccountSecret = Fr.fromHexString('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+  const extraAccountSalt = Fr.ZERO;
+  const extraAccountSigningKey = GrumpkinScalar.random();
+  const extraAccountAddress = await getSchnorrAccountContractAddress(
+    extraAccountSecret,
+    extraAccountSalt,
+    extraAccountSigningKey,
+  );
+
+  logger.info('Starting wallet service...', { l1RpcUrls });
+
+  // createLocalNetwork deploys L1 contracts, starts the node, and optionally deploys funded test accounts (when
+  // TEST_ACCOUNTS=true via env). We are not proving anything just like is done when local network is started by
+  // the `aztecStart` function. The extra account address is passed via prefundAddresses so it gets fee juice at genesis.
+  const { node, stop: stopNetwork } = await createLocalNetwork(
+    { l1RpcUrls, realProofs: false, prefundAddresses: [extraAccountAddress.toString()] },
+    logger.info,
+  );
+
+  // Create an ephemeral embedded wallet backed by the local node.
+  const wallet = await EmbeddedWallet.create(node, { ephemeral: true });
+
+  // Re-register the initial test accounts so they are available via wallet.getAccounts(). createLocalNetwork deploys
+  // them onchain but uses a temporary wallet that is then stopped.
+  //
+  // We use the non-lazy import path (@aztec/accounts/testing, not /lazy) to avoid the dynamic JSON import that is
+  // incompatible with Node.js import attribute enforcement.
+  const testAccountsData = await getInitialTestAccountsData();
+  const accounts = await Promise.all(
+    testAccountsData.map(({ secret, salt, signingKey }) => wallet.createSchnorrAccount(secret, salt, signingKey)),
+  );
+
+  // Register and deploy the 4th account.
+  const extraAccount = await wallet.createSchnorrAccount(extraAccountSecret, extraAccountSalt, extraAccountSigningKey);
+  const deployMethod = await extraAccount.getDeployMethod();
+  await deployMethod.send({ from: accounts[0].address });
+
+  logger.info('Embedded wallet created', {
+    accounts: [...accounts, extraAccount].map(a => a.address.toString()),
+  });
+
+  // Contract artifacts are large, so allow generous body sizes for RPC requests.
+  const rpcOptions = { maxBodySizeBytes: '50mb' };
+
+  // Serve node RPC
+  const nodeRpcServer = createNamespacedSafeJsonRpcServer({ node: [node, AztecNodeApiSchema] }, rpcOptions);
+  const nodeHttpServer = await startHttpRpcServer(nodeRpcServer, { port: NODE_PORT });
+  logger.info(`Node JSON-RPC server listening on port ${nodeHttpServer.port}`);
+
+  // Serve wallet RPC
+  const walletRpcServer = createNamespacedSafeJsonRpcServer({ wallet: [wallet, WalletSchema] }, rpcOptions);
+  const walletHttpServer = await startHttpRpcServer(walletRpcServer, { port: WALLET_PORT });
+  logger.info(`Wallet JSON-RPC server listening on port ${walletHttpServer.port}`);
+
+  const shutdown = async () => {
+    logger.info('Shutting down...');
+    nodeHttpServer.close();
+    walletHttpServer.close();
+    await wallet.stop();
+    await stopNetwork();
+    process.exit(0);
+  };
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGINT', shutdown);
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  process.once('SIGTERM', shutdown);
+}
+
+main().catch(err => {
+  logger.error('Wallet service failed to start', err);
+  process.exit(1);
+});

package/src/guides/up_quick_start.sh

@@ -18,10 +18,8 @@ aztec-wallet() {
 
 aztec-wallet import-test-accounts
 
-# docs:start:declare-accounts
 aztec-wallet create-account -a alice -f test0
 aztec-wallet create-account -a bob -f test0
-# docs:end:declare-accounts
 
 aztec-wallet bridge-fee-juice 1000000000000000000000 accounts:alice --mint --no-wait
 

package/src/shared/gas_portal_test_harness.ts

@@ -178,4 +178,3 @@ export class GasBridgingTestHarness implements IGasBridgingTestHarness {
     }
   }
 }
-// docs:end:cross_chain_test_harness

package/src/shared/uniswap_l1_l2.ts

@@ -154,7 +154,6 @@ export const uniswapL1L2TestSuite = (
       await cleanup();
     });
 
-    // docs:start:uniswap_private
     it('should uniswap trade on L1 from L2 funds privately (swaps WETH -> DAI)', async () => {
       const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
 
@@ -345,10 +344,8 @@ export const uniswapL1L2TestSuite = (
       logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
       logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
     });
-    // docs:end:uniswap_private
 
     // TODO(#7463): reenable look into this failure https://github.com/AztecProtocol/aztec-packages/actions/runs/9912612912/job/27388320150?pr=7462
-    // // docs:start:uniswap_public
     // it('should uniswap trade on L1 from L2 funds publicly (swaps WETH -> DAI)', async () => {
     //   const wethL1BeforeBalance = await wethCrossChainHarness.getL1BalanceOf(ownerEthAddress);
 
@@ -581,7 +578,6 @@ export const uniswapL1L2TestSuite = (
     //   logger.info('WETH balance after swap : ', wethL2BalanceAfterSwap.toString());
     //   logger.info('DAI balance after swap  : ', daiL2BalanceAfterSwap.toString());
     // });
-    // // docs:end:uniswap_public
 
     // Edge cases for the private flow:
     // note - tests for uniswapPortal.sol and minting asset on L2 are covered in other tests.

package/src/spartan/tx_metrics.ts

@@ -1,6 +1,6 @@
 import type { AztecNode } from '@aztec/aztec.js/node';
 import type { Logger } from '@aztec/foundation/log';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockResponse } from '@aztec/stdlib/interfaces/client';
 import type { TopicType } from '@aztec/stdlib/p2p';
 import { Tx, type TxReceipt } from '@aztec/stdlib/tx';
 
@@ -147,7 +147,7 @@ export type TxInclusionData = {
 export class TxInclusionMetrics {
   private data = new Map<string, TxInclusionData>();
   private groups = new Set<string>();
-  private blocks = new Map<number, Promise<L2Block | undefined>>();
+  private blocks = new Map<number, Promise<BlockResponse<{ includeTransactions: true }> | undefined>>();
 
   private p2pGossipLatencyByTopic: Partial<Record<TopicType, { p50: number; p95: number }>> = {};
 
@@ -198,7 +198,7 @@ export class TxInclusionMetrics {
     }
 
     if (!this.blocks.has(blockNumber)) {
-      this.blocks.set(blockNumber, this.aztecNode.getBlock(blockNumber));
+      this.blocks.set(blockNumber, this.aztecNode.getBlock(blockNumber, { includeTransactions: true }));
     }
 
     const block = await this.blocks.get(blockNumber)!;
@@ -229,12 +229,24 @@ export class TxInclusionMetrics {
     p99: number;
   } {
     const histogram = createHistogram({});
+    let nonPositive = 0;
     for (const tx of this.data.values()) {
       if (!tx.blocknumber || tx.group !== group || tx.minedAt === -1) {
         continue;
       }
 
-      histogram.record(tx.minedAt - tx.sentAt);
+      // `minedAt` is the block's L2 slot timestamp (seconds) while `sentAt` is the wall-clock
+      // send time. Because the slot timestamp can precede or equal the send time, the delta
+      // can be <= 0, which perf_hooks.createHistogram rejects. Skip those instead of crashing.
+      const delta = tx.minedAt - tx.sentAt;
+      if (delta <= 0) {
+        nonPositive++;
+        continue;
+      }
+      histogram.record(delta);
+    }
+    if (nonPositive > 0) {
+      this.logger?.debug(`Dropped ${nonPositive} tx inclusion samples with non-positive delta`, { group });
     }
 
     if (histogram.count === 0) {

package/src/test-wallet/test_wallet.ts

@@ -40,6 +40,7 @@ import { ExecutionPayload, mergeExecutionPayloads } from '@aztec/stdlib/tx';
 import { BaseWallet, type SimulateViaEntrypointOptions } from '@aztec/wallet-sdk/base-wallet';
 import type { AccountType } from '@aztec/wallets/embedded';
 
+import { DEFAULT_MIN_FEE_PADDING } from '../fixtures/fixtures.js';
 import { AztecNodeProxy, ProvenTx } from './utils.js';
 
 /**
@@ -63,6 +64,7 @@ export class TestWallet extends BaseWallet {
     private readonly nodeRef: AztecNodeProxy,
   ) {
     super(pxe, nodeRef);
+    this.minFeePadding = DEFAULT_MIN_FEE_PADDING;
   }
 
   static async create(
@@ -178,7 +180,7 @@ export class TestWallet extends BaseWallet {
   }
 
   setMinFeePadding(value?: number) {
-    this.minFeePadding = value ?? 0.5;
+    this.minFeePadding = value ?? DEFAULT_MIN_FEE_PADDING;
   }
 
   protected getAccountFromAddress(address: AztecAddress): Promise<Account> {
@@ -258,7 +260,7 @@ export class TestWallet extends BaseWallet {
     executionPayload: ExecutionPayload,
     opts: SimulateViaEntrypointOptions,
   ): Promise<TxSimulationResultWithAppOffset> {
-    const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement } = opts;
+    const { from, feeOptions, additionalScopes, skipTxValidation, skipFeeEnforcement, sendMessagesAs } = opts;
     const scopes = this.scopesFrom(from, additionalScopes);
     const skipKernels = this.simulationMode !== 'full';
     const useOverride = this.simulationMode === 'kernelless-override';
@@ -308,6 +310,7 @@ export class TestWallet extends BaseWallet {
       skipTxValidation,
       overrides,
       scopes,
+      senderForTags: this.senderForTagsFrom(from, sendMessagesAs),
     });
     const appCallOffset = await this.computeAppCallOffset(from, feeOptions);
     return TxSimulationResultWithAppOffset.fromResultAndOffset(result, appCallOffset);
@@ -320,7 +323,10 @@ export class TestWallet extends BaseWallet {
       gasSettings: opts.fee?.gasSettings,
     });
     const txRequest = await this.createTxExecutionRequestFromPayloadAndFee(exec, opts.from, fee);
-    const txProvingResult = await this.pxe.proveTx(txRequest, this.scopesFrom(opts.from, opts.additionalScopes));
+    const txProvingResult = await this.pxe.proveTx(txRequest, {
+      scopes: this.scopesFrom(opts.from, opts.additionalScopes),
+      senderForTags: this.senderForTagsFrom(opts.from, opts.sendMessagesAs),
+    });
     return new ProvenTx(
       this.aztecNode,
       await txProvingResult.toTx(),