@aztec/end-to-end 2.1.0-rc.1 → 2.1.0-rc.11

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -0,0 +1,174 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js';
+import { RollupContract } from '@aztec/ethereum';
+
+import fs from 'fs';
+import 'jest-extended';
+import os from 'os';
+import path from 'path';
+
+import { createNodes } from '../fixtures/setup_p2p_test.js';
+import { P2PNetworkTest } from './p2p_network.js';
+
+const NUM_NODES = 6;
+const NUM_VALIDATORS = NUM_NODES;
+const COMMITTEE_SIZE = NUM_VALIDATORS;
+const SLASHING_QUORUM = 3;
+const EPOCH_DURATION = 2;
+const SLASHING_ROUND_SIZE_IN_EPOCHS = 2;
+const BOOT_NODE_UDP_PORT = 4500;
+const ETHEREUM_SLOT_DURATION = 4;
+const AZTEC_SLOT_DURATION = 8;
+const SLASHING_UNIT = BigInt(1e18);
+const SLASHING_AMOUNT = SLASHING_UNIT * 3n;
+
+// How many epochs it may take to set everything up, so we dont slash during this period
+const SETUP_EPOCH_DURATION = 5;
+
+export class P2PInactivityTest {
+  public nodes!: AztecNodeService[];
+  public activeNodes!: AztecNodeService[];
+  public inactiveNodes!: AztecNodeService[];
+
+  public rollup!: RollupContract;
+  public offlineValidators!: EthAddress[];
+
+  private dataDir: string;
+  private inactiveNodeCount: number;
+  private keepInitialNode: boolean;
+
+  constructor(
+    public readonly test: P2PNetworkTest,
+    opts: { inactiveNodeCount: number; keepInitialNode?: boolean },
+  ) {
+    this.dataDir = fs.mkdtempSync(path.join(os.tmpdir(), test.testName));
+    this.inactiveNodeCount = opts.inactiveNodeCount;
+    this.keepInitialNode = opts.keepInitialNode ?? false;
+  }
+
+  static async create(
+    testName: string,
+    opts: { slashInactivityConsecutiveEpochThreshold: number; inactiveNodeCount: number; keepInitialNode?: boolean },
+  ) {
+    const test = await P2PNetworkTest.create({
+      testName,
+      numberOfNodes: 0,
+      numberOfValidators: NUM_VALIDATORS,
+      basePort: BOOT_NODE_UDP_PORT,
+      startProverNode: true,
+      initialConfig: {
+        proverNodeConfig: { proverNodeEpochProvingDelayMs: AZTEC_SLOT_DURATION * 1000 },
+        aztecTargetCommitteeSize: COMMITTEE_SIZE,
+        aztecSlotDuration: AZTEC_SLOT_DURATION,
+        ethereumSlotDuration: ETHEREUM_SLOT_DURATION,
+        aztecProofSubmissionEpochs: 1024, // effectively do not reorg
+        listenAddress: '127.0.0.1',
+        minTxsPerBlock: 0,
+        aztecEpochDuration: EPOCH_DURATION,
+        validatorReexecute: false,
+        sentinelEnabled: true,
+        slashingQuorum: SLASHING_QUORUM,
+        slashingRoundSizeInEpochs: SLASHING_ROUND_SIZE_IN_EPOCHS,
+        slashInactivityTargetPercentage: 0.8,
+        slashGracePeriodL2Slots: SETUP_EPOCH_DURATION * EPOCH_DURATION, // do not slash during setup
+        slashAmountSmall: SLASHING_UNIT,
+        slashAmountMedium: SLASHING_UNIT * 2n,
+        slashAmountLarge: SLASHING_UNIT * 3n,
+        ...opts,
+      },
+    });
+    return new P2PInactivityTest(test, opts);
+  }
+
+  public async setup() {
+    await this.test.applyBaseSnapshots();
+    await this.test.setup();
+
+    // Set slashing penalties for inactivity
+    const { rollup } = await this.test.getContracts();
+    const [activationThreshold, ejectionThreshold, localEjectionThreshold] = await Promise.all([
+      rollup.getActivationThreshold(),
+      rollup.getEjectionThreshold(),
+      rollup.getLocalEjectionThreshold(),
+    ]);
+    const biggestEjection = ejectionThreshold > localEjectionThreshold ? ejectionThreshold : localEjectionThreshold;
+    expect(activationThreshold - SLASHING_AMOUNT).toBeLessThan(biggestEjection);
+    this.test.ctx.aztecNodeConfig.slashInactivityPenalty = SLASHING_AMOUNT;
+    this.rollup = rollup;
+
+    if (!this.keepInitialNode) {
+      await this.test.ctx.aztecNode.stop();
+    }
+
+    // Create all active nodes
+    this.activeNodes = await createNodes(
+      this.test.ctx.aztecNodeConfig,
+      this.test.ctx.dateProvider,
+      this.test.bootstrapNodeEnr,
+      NUM_NODES - this.inactiveNodeCount - Number(this.keepInitialNode),
+      BOOT_NODE_UDP_PORT,
+      this.test.prefilledPublicData,
+      this.dataDir,
+      undefined,
+      Number(this.keepInitialNode),
+    );
+
+    // And the ones with an initially disabled sequencer
+    const inactiveConfig = { ...this.test.ctx.aztecNodeConfig, dontStartSequencer: true };
+    this.inactiveNodes = await createNodes(
+      inactiveConfig,
+      this.test.ctx.dateProvider,
+      this.test.bootstrapNodeEnr,
+      this.inactiveNodeCount,
+      BOOT_NODE_UDP_PORT,
+      this.test.prefilledPublicData,
+      this.dataDir,
+      undefined,
+      NUM_NODES - this.inactiveNodeCount,
+    );
+
+    this.nodes = [
+      ...(this.keepInitialNode ? [this.test.ctx.aztecNode] : []),
+      ...this.activeNodes,
+      ...this.inactiveNodes,
+    ];
+
+    if (this.nodes.length !== NUM_NODES) {
+      throw new Error(`Expected ${NUM_NODES} nodes but got ${this.nodes.length}`);
+    }
+
+    this.offlineValidators = this.test.validators
+      .slice(this.test.validators.length - this.inactiveNodeCount)
+      .map(a => a.attester);
+
+    this.test.logger.warn(`Setup complete. Offline validators are ${this.offlineValidators.join(', ')}.`, {
+      validators: this.test.validators,
+      offlineValidators: this.offlineValidators,
+    });
+
+    this.test.logger.warn(`Advancing to epoch ${SETUP_EPOCH_DURATION + 1} to start slashing`);
+    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(SETUP_EPOCH_DURATION + 1);
+
+    return this;
+  }
+
+  public async teardown() {
+    await this.test.stopNodes(this.nodes);
+    await this.test.teardown();
+    for (let i = 0; i < NUM_NODES; i++) {
+      fs.rmSync(`${this.dataDir}-${i}`, { recursive: true, force: true, maxRetries: 3 });
+    }
+  }
+
+  public get ctx() {
+    return this.test.ctx;
+  }
+
+  public get logger() {
+    return this.test.logger;
+  }
+
+  public get slashingAmount() {
+    return SLASHING_AMOUNT;
+  }
+}

package/src/e2e_p2p/p2p_network.ts

@@ -28,9 +28,9 @@ import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { ZkPassportProofParams } from '@aztec/stdlib/zkpassport';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
+import { type GetContractReturnType, getAddress, getContract } from '@spalladino/viem';
+import { privateKeyToAccount } from '@spalladino/viem/accounts';
 import getPort from 'get-port';
-import { type GetContractReturnType, getAddress, getContract } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
 
 import {
   ATTESTER_PRIVATE_KEYS_START_INDEX,
@@ -43,7 +43,7 @@ import {
   createSnapshotManager,
   deployAccounts,
 } from '../fixtures/snapshot_manager.js';
-import { getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
+import { type SetupOptions, getPrivateKeyFromIndex, getSponsoredFPCAddress } from '../fixtures/utils.js';
 import { getEndToEndTestTelemetryClient } from '../fixtures/with_telemetry_utils.js';
 
 // Use a fixed bootstrap node private key so that we can re-use the same snapshot and the nodes can find each other
@@ -82,11 +82,11 @@ export class P2PNetworkTest {
   public bootstrapNode?: BootstrapNode;
 
   constructor(
-    testName: string,
+    public readonly testName: string,
     public bootstrapNodeEnr: string,
     public bootNodePort: number,
     public numberOfValidators: number,
-    initialValidatorConfig: AztecNodeConfig,
+    initialValidatorConfig: SetupOptions,
     public numberOfNodes = 0,
     // If set enable metrics collection
     private metricsPort?: number,
@@ -162,7 +162,7 @@ export class P2PNetworkTest {
     numberOfValidators: number;
     basePort?: number;
     metricsPort?: number;
-    initialConfig?: Partial<AztecNodeConfig>;
+    initialConfig?: SetupOptions;
     startProverNode?: boolean;
     mockZkPassportVerifier?: boolean;
   }) {

package/src/fixtures/e2e_prover_test.ts

@@ -33,8 +33,8 @@ import type { PXEService } from '@aztec/pxe/server';
 import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
-import { type Hex, getContract } from 'viem';
-import { privateKeyToAddress } from 'viem/accounts';
+import { type Hex, getContract } from '@spalladino/viem';
+import { privateKeyToAddress } from '@spalladino/viem/accounts';
 
 import { TokenSimulator } from '../simulators/token_simulator.js';
 import { getACVMConfig } from './get_acvm_config.js';
@@ -308,6 +308,7 @@ export class FullProverTest {
       txGatheringMaxParallelRequestsPerNode: 100,
       txGatheringTimeoutMs: 24_000,
       proverNodeFailedEpochStore: undefined,
+      proverNodeEpochProvingDelayMs: undefined,
     };
     const sponsoredFPCAddress = await getSponsoredFPCAddress();
     const { prefilledPublicData } = await getGenesisValues(

package/src/fixtures/l1_to_l2_messaging.ts

@@ -4,7 +4,7 @@ import { tryJsonStringify } from '@aztec/foundation/json-rpc';
 import { InboxAbi } from '@aztec/l1-artifacts';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import { decodeEventLog, getContract } from 'viem';
+import { decodeEventLog, getContract } from '@spalladino/viem';
 
 import { getLogger } from './utils.js';
 

package/src/fixtures/setup_l1_contracts.ts

@@ -3,8 +3,8 @@ import { type DeployL1ContractsArgs, type L1ContractsConfig, deployL1Contracts }
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 
-import type { HDAccount, PrivateKeyAccount } from 'viem';
-import { foundry } from 'viem/chains';
+import type { HDAccount, PrivateKeyAccount } from '@spalladino/viem';
+import { foundry } from '@spalladino/viem/chains';
 
 export { deployAndInitializeTokenAndBridgeContracts } from '../shared/cross_chain_test_harness.js';
 

package/src/fixtures/setup_p2p_test.ts

@@ -39,7 +39,7 @@ export function generatePrivateKeys(startIndex: number, numberOfKeys: number): `
 }
 
 export async function createNodes(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   bootstrapNodeEnr: string,
   numNodes: number,
@@ -88,7 +88,7 @@ export async function createNodes(
 
 /** Creates a P2P enabled instance of Aztec Node Service with a validator */
 export async function createNode(
-  config: AztecNodeConfig,
+  config: AztecNodeConfig & { dontStartSequencer?: boolean },
   dateProvider: DateProvider,
   tcpPort: number,
   bootstrapNode: string | undefined,
@@ -101,7 +101,11 @@ export async function createNode(
   const createNode = async () => {
     const validatorConfig = await createValidatorConfig(config, bootstrapNode, tcpPort, addressIndex, dataDirectory);
     const telemetry = getEndToEndTestTelemetryClient(metricsPort);
-    return await AztecNodeService.createAndSync(validatorConfig, { telemetry, dateProvider }, { prefilledPublicData });
+    return await AztecNodeService.createAndSync(
+      validatorConfig,
+      { telemetry, dateProvider },
+      { prefilledPublicData, dontStartSequencer: config.dontStartSequencer },
+    );
   };
   return loggerIdStorage ? await loggerIdStorage.run(tcpPort.toString(), createNode) : createNode();
 }

package/src/fixtures/snapshot_manager.ts

@@ -40,6 +40,9 @@ import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { getConfigEnvVars as getTelemetryConfig, initTelemetryClient } from '@aztec/telemetry-client';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
+import type { Hex } from '@spalladino/viem';
+import { mnemonicToAccount } from '@spalladino/viem/accounts';
+import { foundry } from '@spalladino/viem/chains';
 import type { Anvil } from '@viem/anvil';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { copySync, removeSync } from 'fs-extra/esm';
@@ -47,9 +50,6 @@ import fs from 'fs/promises';
 import getPort from 'get-port';
 import { tmpdir } from 'os';
 import path, { join } from 'path';
-import type { Hex } from 'viem';
-import { mnemonicToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
 
 import { MNEMONIC, TEST_MAX_TX_POOL_SIZE, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
@@ -333,14 +333,6 @@ async function setupFromFresh(
   }
   aztecNodeConfig.blobSinkUrl = `http://127.0.0.1:${blobSinkPort}`;
 
-  // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
-  logger.verbose('Starting anvil...');
-  const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
-  const anvil = res.anvil;
-  aztecNodeConfig.l1RpcUrls = [res.rpcUrl];
-
-  // Deploy our L1 contracts.
-  logger.verbose('Deploying L1 contracts...');
   const hdAccount = mnemonicToAccount(MNEMONIC, { addressIndex: 0 });
   const publisherPrivKeyRaw = hdAccount.getHdKey().privateKey;
   const publisherPrivKey = publisherPrivKeyRaw === null ? null : Buffer.from(publisherPrivKeyRaw);
@@ -354,8 +346,17 @@ async function setupFromFresh(
   aztecNodeConfig.validatorPrivateKeys = new SecretValue([`0x${validatorPrivKey!.toString('hex')}`]);
   aztecNodeConfig.coinbase = opts.coinbase ?? EthAddress.fromString(`${hdAccount.address}`);
 
+  logger.info(`Setting up environment with config`, aztecNodeConfig);
+
+  // Start anvil. We go via a wrapper script to ensure if the parent dies, anvil dies.
+  logger.verbose('Starting anvil...');
+  const res = await startAnvil({ l1BlockTime: opts.ethereumSlotDuration });
+  const anvil = res.anvil;
+  aztecNodeConfig.l1RpcUrls = [res.rpcUrl];
   const ethCheatCodes = new EthCheatCodesWithState(aztecNodeConfig.l1RpcUrls);
 
+  // Deploy our L1 contracts.
+  logger.verbose('Deploying L1 contracts...');
   if (opts.l1StartTime) {
     await ethCheatCodes.warp(opts.l1StartTime, { resetBlockInterval: true });
   }
@@ -379,7 +380,6 @@ async function setupFromFresh(
   });
   aztecNodeConfig.l1Contracts = deployL1ContractsValues.l1ContractAddresses;
   aztecNodeConfig.rollupVersion = deployL1ContractsValues.rollupVersion;
-  aztecNodeConfig.l1PublishRetryIntervalMS = 100;
 
   const dateProvider = new TestDateProvider();
 
@@ -432,7 +432,11 @@ async function setupFromFresh(
     proverNode = await createAndSyncProverNode(
       `0x${proverNodePrivateKey!.toString('hex')}`,
       aztecNodeConfig,
-      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')), p2pEnabled: false },
+      {
+        ...aztecNodeConfig.proverNodeConfig,
+        dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+        p2pEnabled: false,
+      },
       aztecNode,
       prefilledPublicData,
     );
@@ -558,7 +562,11 @@ async function setupFromState(statePath: string, logger: Logger): Promise<Subsys
     proverNode = await createAndSyncProverNode(
       proverNodePrivateKeyHex,
       aztecNodeConfig,
-      { dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')) },
+      {
+        ...aztecNodeConfig.proverNodeConfig,
+        dataDirectory: path.join(directoryToCleanup, randomBytes(8).toString('hex')),
+        p2pEnabled: false,
+      },
       aztecNode,
       prefilledPublicData,
     );

package/src/fixtures/utils.ts

@@ -93,14 +93,14 @@ import {
 import { BenchmarkTelemetryClient } from '@aztec/telemetry-client/bench';
 import { getGenesisValues } from '@aztec/world-state/testing';
 
+import { type Chain, type HDAccount, type Hex, type PrivateKeyAccount, getContract } from '@spalladino/viem';
+import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from '@spalladino/viem/accounts';
+import { foundry } from '@spalladino/viem/chains';
 import type { Anvil } from '@viem/anvil';
 import fs from 'fs/promises';
 import getPort from 'get-port';
 import { tmpdir } from 'os';
 import * as path from 'path';
-import { type Chain, type HDAccount, type Hex, type PrivateKeyAccount, getContract } from 'viem';
-import { generatePrivateKey, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
-import { foundry } from 'viem/chains';
 
 import { MNEMONIC, TEST_PEER_CHECK_INTERVAL_MS } from './fixtures.js';
 import { getACVMConfig } from './get_acvm_config.js';
@@ -576,7 +576,7 @@ export async function setup(
     await blobSink.start();
     config.blobSinkUrl = `http://localhost:${blobSinkPort}`;
 
-    logger.verbose('Creating and synching an aztec node...');
+    logger.verbose('Creating and synching an aztec node', config);
 
     const acvmConfig = await getACVMConfig(logger);
     if (acvmConfig) {
@@ -589,7 +589,6 @@ export async function setup(
       config.bbBinaryPath = bbConfig.bbBinaryPath;
       config.bbWorkingDirectory = bbConfig.bbWorkingDirectory;
     }
-    config.l1PublishRetryIntervalMS = 100;
 
     const blobSinkClient = createBlobSinkClient(config, { logger: createLogger('node:blob-sink:client') });
 
@@ -927,7 +926,7 @@ export async function waitForProvenChain(node: AztecNode, targetBlock?: number,
 export function createAndSyncProverNode(
   proverNodePrivateKey: `0x${string}`,
   aztecNodeConfig: AztecNodeConfig,
-  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'>,
+  proverNodeConfig: Partial<ProverNodeConfig> & Pick<DataStoreConfig, 'dataDirectory'> & { dontStart?: boolean },
   aztecNode: AztecNode | undefined,
   prefilledPublicData: PublicDataTreeLeaf[] = [],
   proverNodeDeps: ProverNodeDeps = {},
@@ -963,6 +962,7 @@ export function createAndSyncProverNode(
       txGatheringTimeoutMs: 24_000,
       proverNodeFailedEpochStore: undefined,
       proverId: EthAddress.fromNumber(1),
+      proverNodeEpochProvingDelayMs: undefined,
       ...proverNodeConfig,
     };
 
@@ -979,7 +979,9 @@ export function createAndSyncProverNode(
       { prefilledPublicData },
     );
     getLogger().info(`Created and synced prover node`, { publisherAddress: l1TxUtils.client.account!.address });
-    await proverNode.start();
+    if (!proverNodeConfig.dontStart) {
+      await proverNode.start();
+    }
     return proverNode;
   });
 }

package/src/shared/cross_chain_test_harness.ts

@@ -23,7 +23,7 @@ import { TestERC20Abi, TokenPortalAbi, TokenPortalBytecode } from '@aztec/l1-art
 import { TokenContract } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContract } from '@aztec/noir-contracts.js/TokenBridge';
 
-import { type Hex, getContract } from 'viem';
+import { type Hex, getContract } from '@spalladino/viem';
 
 import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 

package/src/shared/uniswap_l1_l2.ts

@@ -24,7 +24,7 @@ import { computeL2ToL1MessageHash } from '@aztec/stdlib/hash';
 import { computeL2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
 
 import { jest } from '@jest/globals';
-import { type GetContractReturnType, getContract, parseEther, toFunctionSelector } from 'viem';
+import { type GetContractReturnType, getContract, parseEther, toFunctionSelector } from '@spalladino/viem';
 
 import { ensureAccountContractsPublished } from '../fixtures/utils.js';
 import { CrossChainTestHarness } from './cross_chain_test_harness.js';

package/src/spartan/utils.ts

@@ -11,10 +11,10 @@ import {
   createAztecNodeClient,
 } from '@aztec/stdlib/interfaces/client';
 
+import { createPublicClient, fallback, http } from '@spalladino/viem';
 import { ChildProcess, exec, execSync, spawn } from 'child_process';
 import path from 'path';
 import { promisify } from 'util';
-import { createPublicClient, fallback, http } from 'viem';
 import { z } from 'zod';
 
 const execAsync = promisify(exec);