@aztec/end-to-end 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/e2e_l1_publisher/write_json.ts

@@ -0,0 +1,77 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { Fr } from '@aztec/aztec.js/fields';
+import { BatchedBlob, Blob, getEthBlobEvaluationInputs, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L2Block } from '@aztec/stdlib/block';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+
+import { writeFile } from 'fs/promises';
+
+const AZTEC_GENERATE_TEST_DATA = !!process.env.AZTEC_GENERATE_TEST_DATA;
+
+/**
+ * Creates a json object that can be used to test the solidity contract.
+ * The json object must be put into
+ */
+export async function writeJson(
+  fileName: string,
+  checkpointHeader: CheckpointHeader,
+  block: L2Block,
+  l1ToL2Content: Fr[],
+  blobs: Blob[],
+  batchedBlob: BatchedBlob,
+  recipientAddress: AztecAddress,
+  deployerAddress: `0x${string}`,
+): Promise<void> {
+  if (!AZTEC_GENERATE_TEST_DATA) {
+    return;
+  }
+  // Path relative to the package.json in the end-to-end folder
+  const path = `../../l1-contracts/test/fixtures/${fileName}.json`;
+
+  const asHex = (value: Fr | Buffer | EthAddress | AztecAddress, size = 64) => {
+    const buffer = Buffer.isBuffer(value) ? value : value.toBuffer();
+    return `0x${buffer.toString('hex').padStart(size, '0')}`;
+  };
+
+  const jsonObject = {
+    populate: {
+      l1ToL2Content: l1ToL2Content.map(value => asHex(value)),
+      recipient: asHex(recipientAddress.toField()),
+      sender: deployerAddress,
+    },
+    messages: {
+      l2ToL1Messages: block.body.txEffects.flatMap(txEffect => txEffect.l2ToL1Msgs).map(value => asHex(value)),
+    },
+    checkpoint: {
+      // The json formatting in forge is a bit brittle, so we convert Fr to a number in the few values below.
+      // This should not be a problem for testing as long as the values are not larger than u32.
+      archive: asHex(block.archive.root),
+      blobCommitments: getPrefixedEthBlobCommitments(blobs),
+      batchedBlobInputs: getEthBlobEvaluationInputs(batchedBlob),
+      checkpointNumber: block.number,
+      body: `0x${block.body.toBuffer().toString('hex')}`,
+      header: {
+        lastArchiveRoot: asHex(checkpointHeader.lastArchiveRoot),
+        blockHeadersHash: asHex(checkpointHeader.blockHeadersHash),
+        blobsHash: asHex(checkpointHeader.blobsHash),
+        inHash: asHex(checkpointHeader.inHash),
+        outHash: asHex(checkpointHeader.epochOutHash),
+        slotNumber: Number(checkpointHeader.slotNumber),
+        timestamp: Number(checkpointHeader.timestamp),
+        coinbase: asHex(checkpointHeader.coinbase, 40),
+        feeRecipient: asHex(checkpointHeader.feeRecipient),
+        gasFees: {
+          feePerDaGas: Number(checkpointHeader.gasFees.feePerDaGas),
+          feePerL2Gas: Number(checkpointHeader.gasFees.feePerL2Gas),
+        },
+        totalManaUsed: checkpointHeader.totalManaUsed.toNumber(),
+      },
+      headerHash: asHex(checkpointHeader.hash()),
+      numTxs: block.body.txEffects.length,
+    },
+  };
+
+  const output = JSON.stringify(jsonObject, null, 2);
+  await writeFile(path, output, 'utf8');
+}

package/src/e2e_multi_validator/utils.ts

@@ -0,0 +1,258 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import { getAddressFromPrivateKey } from '@aztec/ethereum/account';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { EthPrivateKey } from '@aztec/node-keystore';
+
+import { writeFile } from 'fs/promises';
+import { createServer } from 'http';
+import { signMessage, signTypedData } from 'viem/accounts';
+
+// Create a mock JSON RPC signer
+// Only supports signing messages and type data
+
+const SUPPORTED_METHODS = ['eth_sign', 'eth_signTypedData_v4'];
+
+export function createJSONRPCSigner(keyLookup: Map<string, EthPrivateKey>, stats: Map<string, number>) {
+  return createServer((req, res) => {
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        try {
+          const jsonRequest = JSON.parse(body);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+
+          if (!SUPPORTED_METHODS.includes(jsonRequest.method)) {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                error: { code: -32601, message: 'Method not supported' },
+              }),
+            );
+            return;
+          }
+
+          // Get the address sending the transaction
+          const [address, data] = jsonRequest.params;
+
+          const lowerCaseAddress = address.toLowerCase();
+          stats.set(lowerCaseAddress, (stats.get(lowerCaseAddress) ?? 0) + 1);
+
+          // Find the private key for the address
+          const privateKey = keyLookup.get(address.toLowerCase());
+          if (!privateKey) {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                error: { code: -32602, message: `No private key found for address ${address}` },
+              }),
+            );
+            return;
+          }
+
+          const promise =
+            jsonRequest.method === 'eth_sign'
+              ? signMessage({ message: { raw: data as `0x${string}` }, privateKey })
+              : signTypedData({
+                  privateKey,
+                  ...data,
+                });
+
+          void promise.then(signature => {
+            res.end(
+              JSON.stringify({
+                jsonrpc: '2.0',
+                id: jsonRequest.id,
+                result: signature,
+              }),
+            );
+          });
+        } catch (err) {
+          res.end(
+            JSON.stringify({
+              jsonrpc: '2.0',
+              id: 1,
+              error: { code: -32603, message: `${err}` },
+            }),
+          );
+        }
+      });
+    } else {
+      res.writeHead(405);
+      res.end('Method not allowed');
+    }
+  });
+}
+
+// Functions for creating file based key stores for the e2e_multi_validator_node_key_store test
+export async function createKeyFile1(
+  fileName: string,
+  mnemonic: string,
+  validatorIndex: number,
+  publisher1Key: EthPrivateKey,
+  publisher2Key: EthPrivateKey,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: validatorIndex,
+          addressCount: 1,
+        },
+        coinbase: coinbase.toChecksumString(),
+        publisher: [publisher1Key, publisher2Key],
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile2(
+  fileName: string,
+  validatorKey: EthPrivateKey,
+  publisherMnemonic: string,
+  publisher1Index: number,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: validatorKey,
+        coinbase: coinbase.toChecksumString(),
+        publisher: {
+          mnemonic: publisherMnemonic,
+          accountIndex: 0,
+          addressIndex: publisher1Index,
+          addressCount: 2,
+        },
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile3(
+  fileName: string,
+  validatorAddress: EthAddress,
+  publisher1Key: EthPrivateKey,
+  publisher2Key: EthPrivateKey,
+  coinbase: EthAddress,
+  remoteSignerUrl: string,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: validatorAddress.toChecksumString(),
+        coinbase: coinbase.toChecksumString(),
+        publisher: [publisher1Key, publisher2Key],
+        feeRecipient: feeRecipient.toString(),
+        remoteSigner: {
+          remoteSignerUrl: remoteSignerUrl,
+        },
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile4(
+  fileName: string,
+  validator1Address: EthAddress,
+  validator2Address: EthAddress,
+  publisher1Index: number,
+  publisher2Key: EthPrivateKey,
+  mnemonic: string,
+  publisher3Key: EthPrivateKey,
+  coinbase1: EthAddress,
+  coinbase2: EthAddress,
+  remoteSignerUrl: string,
+  feeRecipient1: AztecAddress,
+  feeRecipient2: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    remoteSigner: {
+      remoteSignerUrl: remoteSignerUrl,
+    },
+    validators: [
+      {
+        attester: validator1Address.toChecksumString(),
+        coinbase: coinbase1.toChecksumString(),
+        publisher: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: publisher1Index,
+          addressCount: 2,
+        },
+        feeRecipient: feeRecipient1.toString(),
+      },
+      {
+        attester: validator2Address.toChecksumString(),
+        coinbase: coinbase2.toChecksumString(),
+        publisher: [publisher2Key, publisher3Key],
+        feeRecipient: feeRecipient2.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile5(fileName: string, proverAddress: EthAddress, remoteSignerUrl: string) {
+  const obj = {
+    schemaVersion: 1,
+    prover: {
+      id: '0x1234567890123456789012345678901234567890',
+      publisher: [
+        {
+          address: proverAddress.toChecksumString(),
+          remoteSignerUrl: remoteSignerUrl,
+        },
+      ],
+    },
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export async function createKeyFile6(
+  fileName: string,
+  mnemonic: string,
+  validator1Index: number,
+  coinbase: EthAddress,
+  feeRecipient: AztecAddress,
+) {
+  const obj = {
+    schemaVersion: 1,
+    validators: [
+      {
+        attester: {
+          mnemonic: mnemonic,
+          accountIndex: 0,
+          addressIndex: validator1Index,
+          addressCount: 2,
+        },
+        coinbase: coinbase.toChecksumString(),
+        feeRecipient: feeRecipient.toString(),
+      },
+    ],
+  };
+  await writeFile(fileName, JSON.stringify(obj, null, 2));
+}
+
+export function addressForPrivateKey(privateKey: EthPrivateKey): EthAddress {
+  return EthAddress.fromString(getAddressFromPrivateKey(privateKey));
+}

package/src/e2e_nested_contract/nested_contract_test.ts

@@ -1,86 +1,73 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import { type AccountWallet, type CompleteAddress, type Logger, type PXE, createLogger } from '@aztec/aztec.js';
-import { ChildContract } from '@aztec/noir-contracts.js/Child';
-import { ParentContract } from '@aztec/noir-contracts.js/Parent';
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+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 { ChildContract } from '@aztec/noir-test-contracts.js/Child';
+import { ParentContract } from '@aztec/noir-test-contracts.js/Parent';
 
 import {
-  type ISnapshotManager,
-  type SubsystemsContext,
-  createSnapshotManager,
+  type EndToEndContext,
   deployAccounts,
   publicDeployAccounts,
-} from '../fixtures/snapshot_manager.js';
-
-const { E2E_DATA_PATH: dataPath } = process.env;
+  setup,
+  teardown as teardownSubsystems,
+} from '../fixtures/setup.js';
 
 export class NestedContractTest {
-  private snapshotManager: ISnapshotManager;
+  context!: EndToEndContext;
   logger: Logger;
-  wallets: AccountWallet[] = [];
-  accounts: CompleteAddress[] = [];
-  pxe!: PXE;
+  wallet!: Wallet;
+  defaultAccountAddress!: AztecAddress;
+  aztecNode!: AztecNode;
 
   parentContract!: ParentContract;
   childContract!: ChildContract;
 
-  constructor(testName: string, private numberOfAccounts = 1) {
+  constructor(
+    testName: string,
+    private numberOfAccounts = 1,
+  ) {
     this.logger = createLogger(`e2e:e2e_nested_contract:${testName}`);
-    this.snapshotManager = createSnapshotManager(`e2e_nested_contract/${testName}-${numberOfAccounts}`, dataPath);
   }
 
   /**
-   * Adds two state shifts to snapshot manager.
-   * 1. Add 3 accounts.
-   * 2. Publicly deploy accounts
+   * Applies base setup by deploying accounts and publicly deploying them.
    */
-  async applyBaseSnapshots() {
-    await this.snapshotManager.snapshot(
-      'accounts',
-      deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { pxe }) => {
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.accounts = await pxe.getRegisteredAccounts();
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        this.pxe = pxe;
-      },
-    );
+  async applyBaseSetup() {
+    this.logger.info('Deploying accounts');
+    const { deployedAccounts } = await deployAccounts(
+      this.numberOfAccounts,
+      this.logger,
+    )({
+      wallet: this.context.wallet,
+      initialFundedAccounts: this.context.initialFundedAccounts,
+    });
+    this.wallet = this.context.wallet;
+    [{ address: this.defaultAccountAddress }] = deployedAccounts;
+    this.aztecNode = this.context.aztecNodeService!;
 
-    await this.snapshotManager.snapshot(
-      'public_deploy',
-      async () => {},
-      async () => {
-        this.logger.verbose(`Public deploy accounts...`);
-        await publicDeployAccounts(this.wallets[0], this.accounts.slice(0, 2));
-      },
-    );
+    this.logger.info('Public deploy accounts');
+    await publicDeployAccounts(this.wallet, [this.defaultAccountAddress]);
   }
 
   async setup() {
-    await this.snapshotManager.setup();
+    this.logger.info('Setting up fresh subsystems');
+    this.context = await setup(0, {
+      fundSponsoredFPC: true,
+      skipAccountDeployment: true,
+    });
+    await this.applyBaseSetup();
   }
 
   async teardown() {
-    await this.snapshotManager.teardown();
+    await teardownSubsystems(this.context);
   }
 
-  snapshot = <T>(
-    name: string,
-    apply: (context: SubsystemsContext) => Promise<T>,
-    restore: (snapshotData: T, context: SubsystemsContext) => Promise<void> = () => Promise.resolve(),
-  ): Promise<void> => this.snapshotManager.snapshot(name, apply, restore);
-
-  async applyManualSnapshots() {
-    await this.snapshotManager.snapshot(
-      'manual',
-      async () => {
-        const parentContract = await ParentContract.deploy(this.wallets[0]).send().deployed();
-        const childContract = await ChildContract.deploy(this.wallets[0]).send().deployed();
-        return { parentContractAddress: parentContract.address, childContractAddress: childContract.address };
-      },
-      async ({ parentContractAddress, childContractAddress }) => {
-        this.parentContract = await ParentContract.at(parentContractAddress, this.wallets[0]);
-        this.childContract = await ChildContract.at(childContractAddress, this.wallets[0]);
-      },
-    );
+  async applyManual() {
+    this.logger.info('Deploying parent and child contracts');
+    const parentContract = await ParentContract.deploy(this.wallet).send({ from: this.defaultAccountAddress });
+    const childContract = await ChildContract.deploy(this.wallet).send({ from: this.defaultAccountAddress });
+    this.parentContract = parentContract;
+    this.childContract = childContract;
   }
 }

package/src/e2e_p2p/inactivity_slash_test.ts

@@ -0,0 +1,179 @@
+import type { AztecNodeService } from '@aztec/aztec-node';
+import { EthAddress } from '@aztec/aztec.js/addresses';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import { EpochNumber } from '@aztec/foundation/branded-types';
+
+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 = process.env.CI ? 8 : 4;
+const AZTEC_SLOT_DURATION = ETHEREUM_SLOT_DURATION * 2;
+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 = 8;
+
+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.setup();
+    await this.test.applyBaseSetup();
+
+    // 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.aztecNodeService!.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.aztecNodeService!] : []),
+      ...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,
+    });
+
+    // Wait for P2P mesh to be fully formed before starting slashing period
+    // This prevents race conditions where validators propose blocks before the network is ready
+    await this.test.waitForP2PMeshConnectivity(this.nodes, NUM_NODES);
+
+    this.test.logger.warn(`Advancing to epoch ${SETUP_EPOCH_DURATION - 1} (slashing will start after it is completed)`);
+    await this.test.ctx.cheatCodes.rollup.advanceToEpoch(EpochNumber(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;
+  }
+}