@aztec/p2p 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2 → 0.76.0

package/src/testbench/scripts/run_testbench.sh

@@ -0,0 +1,7 @@
+## Test bench
+# Run the testbench and pipe the output into a file
+# Usage: ./run_testbench.sh <outputfile>
+
+outputfile=$1
+
+LOG_LEVEL="debug; trace: .*gossipsub" yarn test testbench.test.ts 2>&1 | pino-pretty > $outputfile

package/src/versioning.ts

@@ -0,0 +1,50 @@
+import {
+  type ComponentsVersions,
+  checkCompressedComponentVersion,
+  compressComponentVersions,
+  getComponentsVersionsFromConfig,
+} from '@aztec/circuit-types';
+import { type ChainConfig } from '@aztec/circuit-types/config';
+import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
+import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
+
+import { type SignableENR } from '@chainsafe/enr';
+import xxhashFactory from 'xxhash-wasm';
+
+import { AZTEC_ENR_KEY } from './services/types.js';
+
+const USE_XX_HASH = false; // Enable to reduce the size of the ENR record for production
+const XX_HASH_LEN = 8;
+const xxhash = await xxhashFactory();
+
+/** Returns the component versions based on config and this build. */
+export function getVersions(config: ChainConfig) {
+  return getComponentsVersionsFromConfig(config, protocolContractTreeRoot, getVKTreeRoot());
+}
+
+/** Sets the aztec key on the ENR record with versioning info. */
+export function setAztecEnrKey(enr: SignableENR, config: ChainConfig, useXxHash = USE_XX_HASH) {
+  const versions = getVersions(config);
+  const value = versionsToEnrValue(versions, useXxHash);
+  enr.set(AZTEC_ENR_KEY, value);
+  return versions;
+}
+
+/** Checks the given value from an ENR record against the expected versions. */
+export function checkAztecEnrVersion(enrValue: Buffer, expectedVersions: ComponentsVersions) {
+  if (enrValue.length === XX_HASH_LEN) {
+    const expected = versionsToEnrValue(expectedVersions, true);
+    if (!Buffer.from(enrValue).equals(expected)) {
+      throw new Error(`Expected ENR version ${expected.toString('hex')} but received ${enrValue.toString('hex')}`);
+    }
+  } else {
+    const actual = Buffer.from(enrValue).toString();
+    checkCompressedComponentVersion(actual, expectedVersions);
+  }
+}
+
+function versionsToEnrValue(versions: ComponentsVersions, useXxHash: boolean) {
+  const compressed = compressComponentVersions(versions);
+  return useXxHash ? toBufferBE(xxhash.h64(compressed), XX_HASH_LEN) : Buffer.from(compressed);
+}

package/dest/mocks/index.js

@@ -1,190 +0,0 @@
-import { timesParallel } from '@aztec/foundation/collection';
-import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import { gossipsub } from '@chainsafe/libp2p-gossipsub';
-import { noise } from '@chainsafe/libp2p-noise';
-import { yamux } from '@chainsafe/libp2p-yamux';
-import { bootstrap } from '@libp2p/bootstrap';
-import { identify } from '@libp2p/identify';
-import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
-import { tcp } from '@libp2p/tcp';
-import getPort from 'get-port';
-import { createLibp2p } from 'libp2p';
-import { BootstrapNode } from '../bootstrap/bootstrap.js';
-import { DiscV5Service } from '../services/discv5/discV5_service.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
-import { ReqRespSubProtocol, noopValidator } from '../services/reqresp/interface.js';
-import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
-import { ReqResp } from '../services/reqresp/reqresp.js';
-/**
- * Creates a libp2p node, pre configured.
- * @param boostrapAddrs - an optional list of bootstrap addresses
- * @returns Lip2p node
- */ export async function createLibp2pNode(boostrapAddrs = [], peerId, port, enableGossipSub = false, start = true) {
-    port = port ?? await getPort();
-    const options = {
-        start,
-        addresses: {
-            listen: [
-                `/ip4/0.0.0.0/tcp/${port}`
-            ],
-            announce: [
-                `/ip4/0.0.0.0/tcp/${port}`
-            ]
-        },
-        connectionEncryption: [
-            noise()
-        ],
-        streamMuxers: [
-            yamux()
-        ],
-        transports: [
-            tcp()
-        ],
-        services: {
-            identify: identify({
-                protocolPrefix: 'aztec'
-            })
-        }
-    };
-    if (boostrapAddrs.length > 0) {
-        options.peerDiscovery = [
-            bootstrap({
-                list: boostrapAddrs
-            })
-        ];
-    }
-    if (peerId) {
-        options.peerId = peerId;
-    }
-    if (enableGossipSub) {
-        options.services.pubsub = gossipsub({
-            allowPublishToZeroTopicPeers: true
-        });
-    }
-    return await createLibp2p(options);
-}
-/**
- * Test Libp2p service
- * P2P functionality is operational, however everything else is default
- *
- *
- */ export async function createTestLibP2PService(clientType, boostrapAddrs = [], l2BlockSource, worldStateSynchronizer, epochCache, mempools, telemetry, port = 0, peerId) {
-    peerId = peerId ?? await createSecp256k1PeerId();
-    const config = {
-        tcpAnnounceAddress: `127.0.0.1:${port}`,
-        udpAnnounceAddress: `127.0.0.1:${port}`,
-        tcpListenAddress: `0.0.0.0:${port}`,
-        udpListenAddress: `0.0.0.0:${port}`,
-        bootstrapNodes: boostrapAddrs,
-        peerCheckIntervalMS: 1000,
-        minPeerCount: 1,
-        maxPeerCount: 5,
-        p2pEnabled: true,
-        peerIdPrivateKey: Buffer.from(peerId.privateKey).toString('hex')
-    };
-    const discoveryService = new DiscV5Service(peerId, config, telemetry);
-    const proofVerifier = new AlwaysTrueCircuitVerifier();
-    // No bootstrap nodes provided as the libp2p service will register them in the constructor
-    const p2pNode = await createLibp2pNode([], peerId, port, /*enable gossip */ true, /**start */ false);
-    return new LibP2PService(clientType, config, p2pNode, discoveryService, mempools, l2BlockSource, epochCache, proofVerifier, worldStateSynchronizer, telemetry);
-}
-// Mock sub protocol handlers
-export const MOCK_SUB_PROTOCOL_HANDLERS = {
-    [ReqRespSubProtocol.PING]: pingHandler,
-    [ReqRespSubProtocol.STATUS]: statusHandler,
-    [ReqRespSubProtocol.TX]: (_msg)=>Promise.resolve(Buffer.from('tx')),
-    [ReqRespSubProtocol.GOODBYE]: (_msg)=>Promise.resolve(Buffer.from('goodbye')),
-    [ReqRespSubProtocol.BLOCK]: (_msg)=>Promise.resolve(Buffer.from('block'))
-};
-// By default, all requests are valid
-// If you want to test an invalid response, you can override the validator
-export const MOCK_SUB_PROTOCOL_VALIDATORS = {
-    [ReqRespSubProtocol.PING]: noopValidator,
-    [ReqRespSubProtocol.STATUS]: noopValidator,
-    [ReqRespSubProtocol.TX]: noopValidator,
-    [ReqRespSubProtocol.GOODBYE]: noopValidator,
-    [ReqRespSubProtocol.BLOCK]: noopValidator
-};
-/**
- * @param numberOfNodes - the number of nodes to create
- * @returns An array of the created nodes
- */ export const createNodes = (peerScoring, numberOfNodes)=>{
-    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring));
-};
-export const startNodes = async (nodes, subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS, subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS)=>{
-    for (const node of nodes){
-        await node.req.start(subProtocolHandlers, subProtocolValidators);
-    }
-};
-export const stopNodes = async (nodes)=>{
-    const stopPromises = nodes.flatMap((node)=>[
-            node.req.stop(),
-            node.p2p.stop()
-        ]);
-    await Promise.all(stopPromises);
-};
-// Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring)=>{
-    const p2p = await createLibp2pNode();
-    const config = {
-        overallRequestTimeoutMs: 4000,
-        individualRequestTimeoutMs: 2000
-    };
-    const req = new ReqResp(config, p2p, peerScoring);
-    return {
-        p2p,
-        req
-    };
-};
-// Given a node list; hand shake all of the nodes with each other
-export const connectToPeers = async (nodes)=>{
-    for (const node of nodes){
-        for (const otherNode of nodes){
-            if (node === otherNode) {
-                continue;
-            }
-            const addr = otherNode.p2p.getMultiaddrs()[0];
-            await node.p2p.dial(addr);
-        }
-    }
-};
-// Mock circuit verifier for testing - reimplementation from bb to avoid dependency
-export class AlwaysTrueCircuitVerifier {
-    verifyProof(_tx) {
-        return Promise.resolve(true);
-    }
-}
-export class AlwaysFalseCircuitVerifier {
-    verifyProof(_tx) {
-        return Promise.resolve(false);
-    }
-}
-// Bootnodes
-export function createBootstrapNodeConfig(privateKey, port) {
-    return {
-        udpListenAddress: `0.0.0.0:${port}`,
-        udpAnnounceAddress: `127.0.0.1:${port}`,
-        peerIdPrivateKey: privateKey,
-        minPeerCount: 10,
-        maxPeerCount: 100,
-        dataDirectory: undefined,
-        dataStoreMapSizeKB: 0
-    };
-}
-export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry = getTelemetryClient()) {
-    const config = createBootstrapNodeConfig(privateKey, port);
-    return startBootstrapNode(config, telemetry);
-}
-export async function createBootstrapNode(port, telemetry = getTelemetryClient()) {
-    const peerId = await createSecp256k1PeerId();
-    const config = createBootstrapNodeConfig(Buffer.from(peerId.privateKey).toString('hex'), port);
-    return startBootstrapNode(config, telemetry);
-}
-async function startBootstrapNode(config, telemetry) {
-    // Open an ephemeral store that will only exist in memory
-    const store = await openTmpStore('bootstrap-node', true);
-    const bootstrapNode = new BootstrapNode(store, telemetry);
-    await bootstrapNode.start(config);
-    return bootstrapNode;
-}