feat: introduce validator client

cspell.json

@@ -105,6 +105,7 @@
     "fuzzers",
     "gitmodules",
     "gitrepo",
+    "Gossipable",
     "gossipsub",
     "grumpkin",
     "gtest",

yarn-project/aztec-node/package.json

@@ -72,6 +72,7 @@
     "@aztec/simulator": "workspace:^",
     "@aztec/telemetry-client": "workspace:^",
     "@aztec/types": "workspace:^",
+    "@aztec/validator-client": "workspace:^",
     "@aztec/world-state": "workspace:^",
     "koa": "^2.14.2",
     "koa-router": "^12.0.0",

yarn-project/aztec-node/src/aztec-node/config.ts

@@ -3,6 +3,7 @@ import { type ConfigMappingsType, getConfigFromMappings } from '@aztec/foundatio
 import { type P2PConfig, p2pConfigMappings } from '@aztec/p2p';
 import { type ProverClientConfig, proverClientConfigMappings } from '@aztec/prover-client';
 import { type SequencerClientConfig, sequencerClientConfigMappings } from '@aztec/sequencer-client';
+import { type ValidatorClientConfig, validatorClientConfigMappings } from '@aztec/validator-client';
 import { type WorldStateConfig, worldStateConfigMappings } from '@aztec/world-state';
 
 import { readFileSync } from 'fs';
@@ -16,6 +17,7 @@ export { sequencerClientConfigMappings, SequencerClientConfig } from '@aztec/seq
  */
 export type AztecNodeConfig = ArchiverConfig &
   SequencerClientConfig &
+  ValidatorClientConfig &
   ProverClientConfig &
   WorldStateConfig &
   P2PConfig & {
@@ -24,11 +26,16 @@ export type AztecNodeConfig = ArchiverConfig &
 
     /** Whether the prover is disabled for this node. */
     disableProver: boolean;
+
+    // TODO(md): needed?
+    /** Whether the validator is disabled for this node */
+    disableValidator: boolean;
   };
 
 export const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig> = {
   ...archiverConfigMappings,
   ...sequencerClientConfigMappings,
+  ...validatorClientConfigMappings,
   ...proverClientConfigMappings,
   ...worldStateConfigMappings,
   ...p2pConfigMappings,
@@ -44,6 +51,12 @@ export const aztecNodeConfigMappings: ConfigMappingsType<AztecNodeConfig> = {
     default: false,
     description: 'Whether the prover is disabled for this node.',
   },
+  disableValidator: {
+    env: 'VALIDATOR_DISABLED',
+    parseEnv: (val: string) => ['1', 'true'].includes(val),
+    default: false,
+    description: 'Whether the validator is disabled for this node.',
+  },
 };
 
 /**

yarn-project/aztec-node/src/aztec-node/server.ts

@@ -53,7 +53,7 @@ import { Timer } from '@aztec/foundation/timer';
 import { type AztecKVStore } from '@aztec/kv-store';
 import { createStore, openTmpStore } from '@aztec/kv-store/utils';
 import { SHA256Trunc, StandardTree, UnbalancedTree } from '@aztec/merkle-tree';
-import { AztecKVTxPool, type P2P, createP2PClient } from '@aztec/p2p';
+import { AztecKVTxPool, InMemoryAttestationPool, type P2P, createP2PClient } from '@aztec/p2p';
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
@@ -76,6 +76,7 @@ import {
   type ContractInstanceWithAddress,
   type ProtocolContractAddresses,
 } from '@aztec/types/contracts';
+import { createValidatorClient } from '@aztec/validator-client';
 import { MerkleTrees, type WorldStateSynchronizer, createWorldStateSynchronizer } from '@aztec/world-state';
 
 import { type AztecNodeConfig, getPackageInfo } from './config.js';
@@ -152,7 +153,13 @@ export class AztecNodeService implements AztecNode {
     config.transactionProtocol = `/aztec/tx/${config.l1Contracts.rollupAddress.toString()}`;
 
     // create the tx pool and the p2p client, which will need the l2 block source
-    const p2pClient = await createP2PClient(config, store, new AztecKVTxPool(store, telemetry), archiver);
+    const p2pClient = await createP2PClient(
+      config,
+      store,
+      new AztecKVTxPool(store, telemetry),
+      new InMemoryAttestationPool(),
+      archiver,
+    );
 
     // now create the merkle trees and the world state synchronizer
     const worldStateSynchronizer = await createWorldStateSynchronizer(config, store, archiver);
@@ -175,11 +182,16 @@ export class AztecNodeService implements AztecNode {
       throw new Error("Can't start a sequencer without a prover");
     }
 
+    // TODO: likely that the sequencer will consume a validator client and use it
+    // to broadcast the blocks
+    const validatorClient = createValidatorClient(config, p2pClient);
+
     // now create the sequencer
     const sequencer = config.disableSequencer
       ? undefined
       : await SequencerClient.new(
           config,
+          validatorClient,
           p2pClient,
           worldStateSynchronizer,
           archiver,

yarn-project/circuit-types/package.json

@@ -80,7 +80,8 @@
     "jest": "^29.5.0",
     "jest-mock-extended": "^3.0.3",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "viem": "^2.7.15"
   },
   "files": [
     "dest",

yarn-project/circuit-types/src/p2p/block_attestation.ts

@@ -1,7 +1,9 @@
-import { Header } from '@aztec/circuits.js';
+import { EthAddress, Header } from '@aztec/circuits.js';
 import { BaseHashType } from '@aztec/foundation/hash';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import { recoverAddress } from 'viem';
+
 import { Gossipable } from './gossipable.js';
 import { TopicType, createTopicString } from './topic_type.js';
 
@@ -20,6 +22,8 @@ export class BlockAttestationHash extends BaseHashType {
 export class BlockAttestation extends Gossipable {
   static override p2pTopic: string;
 
+  private sender: EthAddress | undefined;
+
   constructor(
     /** The block header the attestation is made over */
     public readonly header: Header,
@@ -37,6 +41,25 @@ export class BlockAttestation extends Gossipable {
     return BlockAttestationHash.fromField(this.header.hash());
   }
 
+  /**Get sender
+   *
+   * Lazily evaluate and cache the sender of the attestation
+   * @returns The sender of the attestation
+   */
+  async getSender() {
+    if (!this.sender) {
+      // Recover the sender from the attestation
+      const address = await recoverAddress({
+        hash: this.p2pMessageIdentifier().to0xString(),
+        signature: this.signature,
+      });
+      // Cache the sender for later use
+      this.sender = EthAddress.fromString(address);
+    }
+
+    return this.sender;
+  }
+
   toBuffer(): Buffer {
     return serializeToBuffer([this.header, this.signature.length, this.signature]);
   }
@@ -45,4 +68,8 @@ export class BlockAttestation extends Gossipable {
     const reader = BufferReader.asReader(buf);
     return new BlockAttestation(reader.readObject(Header), reader.readBuffer());
   }
+
+  static empty(): BlockAttestation {
+    return new BlockAttestation(Header.empty(), Buffer.from([]));
+  }
 }

yarn-project/circuit-types/src/p2p/block_proposal.ts

@@ -2,7 +2,7 @@ import { Header } from '@aztec/circuits.js';
 import { BaseHashType } from '@aztec/foundation/hash';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { TxHash } from '../index.js';
+import { TxHash } from '../tx/tx_hash.js';
 import { Gossipable } from './gossipable.js';
 import { TopicType, createTopicString } from './topic_type.js';
 

yarn-project/circuit-types/src/p2p/block_with_attestations.test.ts

@@ -0,0 +1,6 @@
+describe('Block with Attestations', () => {
+  it('Should be able to be constructed from attestations', () => {
+    //todo
+    expect(true).toEqual(false);
+  });
+});

yarn-project/circuit-types/src/p2p/block_with_attestations.ts

@@ -0,0 +1,21 @@
+import { type BlockAttestation } from './block_attestation.js';
+import { type BlockProposal } from './block_proposal.js';
+
+/**
+ * BlockWithAttestations
+ * A data structure that contains a block proposal with it's attestations attached
+ */
+export class BlockWithAttestations {
+  constructor(
+    public readonly block: BlockProposal,
+    /** Signatures of the attestations */
+    public readonly attestations: Buffer[],
+  ) {}
+
+  static fromBlockAndBlockAttestations(block: BlockProposal, attestations: BlockAttestation[]): BlockWithAttestations {
+    return new BlockWithAttestations(
+      block,
+      attestations.map(attestation => attestation.signature),
+    );
+  }
+}

yarn-project/circuit-types/src/p2p/index.ts

@@ -1,4 +1,5 @@
 export * from './block_attestation.js';
+export * from './block_with_attestations.js';
 export * from './block_proposal.js';
 export * from './interface.js';
 export * from './gossipable.js';

yarn-project/circuits.js/src/structs/header.ts

@@ -11,6 +11,8 @@ import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
 export class Header {
+  private blockHash: Fr | undefined;
+
   constructor(
     /** Snapshot of archive before the block is applied. */
     public lastArchive: AppendOnlyTreeSnapshot,
@@ -123,6 +125,9 @@ export class Header {
   }
 
   hash(): Fr {
-    return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+    if (!this.blockHash) {
+      this.blockHash = poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
+    }
+    return this.blockHash;
   }
 }

yarn-project/end-to-end/src/e2e_p2p_attestations.test.ts

@@ -0,0 +1,140 @@
+import { getSchnorrAccount } from '@aztec/accounts/schnorr';
+import { type AztecNodeConfig, type AztecNodeService } from '@aztec/aztec-node';
+import { CompleteAddress, type DebugLogger, Fr, GrumpkinScalar, TxStatus, sleep } from '@aztec/aztec.js';
+import { type BootstrapNode } from '@aztec/p2p';
+import { type PXEService, createPXEService, getPXEServiceConfig as getRpcConfig } from '@aztec/pxe';
+
+import fs from 'fs';
+
+import {
+  type NodeContext,
+  createBootstrapNode,
+  createNodes,
+  generatePeerIdPrivateKeys,
+} from './fixtures/setup_p2p_test.js';
+import { setup } from './fixtures/utils.js';
+
+// Don't set this to a higher value than 9 because each node will use a different L1 publisher account and anvil seeds
+const NUM_NODES = 4;
+const NUM_TXS_PER_BLOCK = 4;
+const BOOT_NODE_UDP_PORT = 40400;
+
+const PEER_ID_PRIVATE_KEYS = generatePeerIdPrivateKeys(NUM_NODES);
+
+describe('e2e_p2p_attestations', () => {
+  let config: AztecNodeConfig;
+  let logger: DebugLogger;
+  let teardown: () => Promise<void>;
+  let bootstrapNode: BootstrapNode;
+  let bootstrapNodeEnr: string;
+
+  beforeEach(async () => {
+    // TODO: cleanup this test Enable validators
+    ({ teardown, config, logger } = await setup(0));
+    bootstrapNode = await createBootstrapNode(BOOT_NODE_UDP_PORT);
+    bootstrapNodeEnr = bootstrapNode.getENR().encodeTxt();
+
+    // TODO: refactor? Config settings
+    config.minTxsPerBlock = NUM_TXS_PER_BLOCK;
+    config.maxTxsPerBlock = NUM_TXS_PER_BLOCK;
+  });
+
+  afterEach(() => teardown());
+
+  afterAll(() => {
+    for (let i = 0; i < NUM_NODES; i++) {
+      fs.rmSync(`./data-${i}`, { recursive: true, force: true });
+    }
+  });
+
+  it('should collect attestations from all peers', async () => {
+    // create the bootstrap node for the network
+    if (!bootstrapNodeEnr) {
+      throw new Error('Bootstrap node ENR is not available');
+    }
+
+    // Create a network of nodes where they will not produce a block until
+    // they have collected enough attestations for the block from their peers
+    // at this moment in time the threshold is hardcoded within the validator client
+    const contexts: NodeContext[] = [];
+    const nodes: AztecNodeService[] = await createNodes(
+      config,
+      PEER_ID_PRIVATE_KEYS,
+      bootstrapNodeEnr,
+      NUM_NODES,
+      BOOT_NODE_UDP_PORT,
+      /*activate validators*/ true,
+    );
+
+    // wait a bit for peers to discover each other
+    await sleep(2000);
+
+    // just send one transaction for now
+    for (const node of nodes) {
+      const context = await createPXEServiceAndSubmitTransactions(node);
+      contexts.push(context);
+    }
+
+    // now ensure that all txs were successfully mined
+    await Promise.all(
+      contexts.flatMap((context, i) =>
+        context.txs.map(async (tx, j) => {
+          logger.info(`Waiting for tx ${i}-${j}: ${await tx.getTxHash()} to be mined`);
+          return tx.wait();
+        }),
+      ),
+    );
+
+    // shutdown all nodes.
+    for (const context of contexts) {
+      await context.node.stop();
+      await context.pxeService.stop();
+    }
+    await bootstrapNode.stop();
+  });
+
+  // creates an instance of the PXE and submit a given number of transactions to it.
+  const createPXEServiceAndSubmitTransactions = async (node: AztecNodeService): Promise<NodeContext> => {
+    const rpcConfig = getRpcConfig();
+    const pxeService = await createPXEService(node, rpcConfig, true);
+
+    const secretKey = Fr.random();
+    const completeAddress = CompleteAddress.fromSecretKeyAndPartialAddress(secretKey, Fr.random());
+    await pxeService.registerAccount(secretKey, completeAddress.partialAddress);
+
+    const tx = await submitTx(pxeService);
+    return {
+      txs: [tx],
+      account: completeAddress.address,
+      pxeService,
+      node,
+    };
+  };
+
+  // submits a set of transactions to the provided Private eXecution Environment (PXE)
+  const submitTx = async (pxe: PXEService) => {
+    const accountManager = getSchnorrAccount(pxe, Fr.random(), GrumpkinScalar.random(), Fr.random());
+    const deployMethod = await accountManager.getDeployMethod();
+    await deployMethod.create({
+      contractAddressSalt: accountManager.salt,
+      skipClassRegistration: true,
+      skipPublicDeployment: true,
+      universalDeploy: true,
+    });
+    await deployMethod.prove({});
+    const tx = deployMethod.send();
+
+    const txHash = await tx.getTxHash();
+
+    logger.info(`Tx sent with hash ${txHash}`);
+    const receipt = await tx.getReceipt();
+    expect(receipt).toEqual(
+      expect.objectContaining({
+        status: TxStatus.PENDING,
+        error: '',
+      }),
+    );
+    logger.info(`Receipt received for ${txHash}`);
+    return tx;
+  };
+});