@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/dest/test-helpers/reqresp-nodes.js

@@ -1,8 +1,10 @@
 import { timesParallel } from '@aztec/foundation/collection';
+import { SecretValue } from '@aztec/foundation/config';
+import { createLogger } from '@aztec/foundation/log';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
 import { emptyChainConfig } from '@aztec/stdlib/config';
+import { compressComponentVersions } from '@aztec/stdlib/versioning';
 import { getTelemetryClient } from '@aztec/telemetry-client';
-import { SignableENR } from '@chainsafe/enr';
 import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { noise } from '@chainsafe/libp2p-noise';
 import { yamux } from '@chainsafe/libp2p-yamux';
@@ -11,15 +13,19 @@ import { identify } from '@libp2p/identify';
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 import { tcp } from '@libp2p/tcp';
 import { multiaddr } from '@multiformats/multiaddr';
+import { SignableENR } from '@nethermindeth/enr';
 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 { PeerManager } from '../services/peer-manager/peer_manager.js';
+import { PeerScoring } from '../services/peer-manager/peer_scoring.js';
 import { ReqRespSubProtocol, noopValidator } from '../services/reqresp/interface.js';
-import { pingHandler, statusHandler } from '../services/reqresp/protocols/index.js';
+import { pingHandler } from '../services/reqresp/protocols/index.js';
 import { ReqResp } from '../services/reqresp/reqresp.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { getVersions } from '../versioning.js';
 /**
  * Creates a libp2p node, pre configured.
  * @param boostrapAddrs - an optional list of bootstrap addresses
@@ -30,10 +36,10 @@ import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js
         start,
         addresses: {
             listen: [
-                `/ip4/0.0.0.0/tcp/${port}`
+                `/ip4/127.0.0.1/tcp/${port}`
             ],
             announce: [
-                `/ip4/0.0.0.0/tcp/${port}`
+                `/ip4/127.0.0.1/tcp/${port}`
             ]
         },
         connectionEncryption: [
@@ -73,34 +79,42 @@ import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js
  * P2P functionality is operational, however everything else is default
  *
  *
- */ export async function createTestLibP2PService(clientType, boostrapAddrs = [], l2BlockSource, worldStateSynchronizer, epochCache, mempools, telemetry, port = 0, peerId, chainConfig = emptyChainConfig) {
+ */ export async function createTestLibP2PService(clientType, boostrapAddrs = [], archiver, worldStateSynchronizer, epochCache, mempools, telemetry, port = 0, peerId, chainConfig = emptyChainConfig) {
     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}`,
+        p2pIp: `127.0.0.1`,
+        p2pPort: port,
         bootstrapNodes: boostrapAddrs,
         peerCheckIntervalMS: 1000,
         maxPeerCount: 5,
         p2pEnabled: true,
-        peerIdPrivateKey: Buffer.from(peerId.privateKey).toString('hex'),
+        peerIdPrivateKey: new SecretValue(Buffer.from(peerId.privateKey).toString('hex')),
         bootstrapNodeEnrVersionCheck: false,
         ...chainConfig
     };
-    const discoveryService = new DiscV5Service(peerId, config, telemetry);
+    const discoveryService = new DiscV5Service(peerId, config, 'test-reqresp-node', 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);
+    // Duplicated setup code from Libp2pService.new
+    const peerScoring = new PeerScoring(config);
+    const reqresp = new ReqResp(config, p2pNode, peerScoring);
+    const versions = getVersions(config);
+    const protocolVersion = compressComponentVersions(versions);
+    const peerManager = new PeerManager(p2pNode, discoveryService, config, telemetry, createLogger(`p2p:peer_manager`), peerScoring, reqresp, worldStateSynchronizer, protocolVersion, epochCache);
+    p2pNode.services.pubsub.score.params.appSpecificWeight = 10;
+    p2pNode.services.pubsub.score.params.appSpecificScore = (peerId)=>peerManager.shouldDisableP2PGossip(peerId) ? -Infinity : peerManager.getPeerScore(peerId);
+    return new LibP2PService(clientType, config, p2pNode, discoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry);
 }
 // Mock sub protocol handlers
 export const MOCK_SUB_PROTOCOL_HANDLERS = {
     [ReqRespSubProtocol.PING]: pingHandler,
-    [ReqRespSubProtocol.STATUS]: statusHandler,
+    [ReqRespSubProtocol.STATUS]: (_msg)=>Promise.resolve(Buffer.from('status')),
     [ReqRespSubProtocol.TX]: (_msg)=>Promise.resolve(Buffer.from('tx')),
     [ReqRespSubProtocol.GOODBYE]: (_msg)=>Promise.resolve(Buffer.from('goodbye')),
-    [ReqRespSubProtocol.BLOCK]: (_msg)=>Promise.resolve(Buffer.from('block'))
+    [ReqRespSubProtocol.BLOCK]: (_msg)=>Promise.resolve(Buffer.from('block')),
+    [ReqRespSubProtocol.AUTH]: (_msg)=>Promise.resolve(Buffer.from('auth')),
+    [ReqRespSubProtocol.BLOCK_TXS]: (_msg)=>Promise.resolve(Buffer.from('block_txs'))
 };
 // By default, all requests are valid
 // If you want to test an invalid response, you can override the validator
@@ -109,13 +123,15 @@ export const MOCK_SUB_PROTOCOL_VALIDATORS = {
     [ReqRespSubProtocol.STATUS]: noopValidator,
     [ReqRespSubProtocol.TX]: noopValidator,
     [ReqRespSubProtocol.GOODBYE]: noopValidator,
-    [ReqRespSubProtocol.BLOCK]: noopValidator
+    [ReqRespSubProtocol.BLOCK]: noopValidator,
+    [ReqRespSubProtocol.AUTH]: noopValidator,
+    [ReqRespSubProtocol.BLOCK_TXS]: 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 createNodes = (peerScoring, numberOfNodes, rateLimits = {})=>{
+    return timesParallel(numberOfNodes, ()=>createReqResp(peerScoring, rateLimits));
 };
 export const startNodes = async (nodes, subProtocolHandlers = MOCK_SUB_PROTOCOL_HANDLERS, subProtocolValidators = MOCK_SUB_PROTOCOL_VALIDATORS)=>{
     for (const node of nodes){
@@ -130,13 +146,15 @@ export const stopNodes = async (nodes)=>{
     await Promise.all(stopPromises);
 };
 // Create a req resp node, exposing the underlying p2p node
-export const createReqResp = async (peerScoring)=>{
+export const createReqResp = async (peerScoring, rateLimits = {})=>{
     const p2p = await createLibp2pNode();
     const config = {
         overallRequestTimeoutMs: 4000,
-        individualRequestTimeoutMs: 2000
+        individualRequestTimeoutMs: 2000,
+        dialTimeoutMs: 1000,
+        p2pOptimisticNegotiation: false
     };
-    const req = new ReqResp(config, p2p, peerScoring);
+    const req = new ReqResp(config, p2p, peerScoring, undefined, rateLimits);
     return {
         p2p,
         req
@@ -156,25 +174,41 @@ export const connectToPeers = async (nodes)=>{
 };
 // Mock circuit verifier for testing - reimplementation from bb to avoid dependency
 export class AlwaysTrueCircuitVerifier {
+    stop() {
+        return Promise.resolve();
+    }
     verifyProof(_tx) {
-        return Promise.resolve(true);
+        return Promise.resolve({
+            valid: true,
+            durationMs: 0,
+            totalDurationMs: 0
+        });
     }
 }
 export class AlwaysFalseCircuitVerifier {
+    stop() {
+        return Promise.resolve();
+    }
     verifyProof(_tx) {
-        return Promise.resolve(false);
+        return Promise.resolve({
+            valid: false,
+            durationMs: 0,
+            totalDurationMs: 0
+        });
     }
 }
 // Bootnodes
 export function createBootstrapNodeConfig(privateKey, port, chainConfig) {
     return {
         l1ChainId: chainConfig.l1ChainId,
-        udpListenAddress: `0.0.0.0:${port}`,
-        udpAnnounceAddress: `127.0.0.1:${port}`,
-        peerIdPrivateKey: privateKey,
+        p2pIp: '127.0.0.1',
+        p2pPort: port,
+        peerIdPrivateKey: new SecretValue(privateKey),
         dataDirectory: undefined,
-        dataStoreMapSizeKB: 0,
-        bootstrapNodes: []
+        dataStoreMapSizeKb: 0,
+        bootstrapNodes: [],
+        listenAddress: '127.0.0.1',
+        queryForIp: false
     };
 }
 export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry = getTelemetryClient(), chainConfig = emptyChainConfig) {
@@ -189,7 +223,7 @@ export function createBootstrapNodeFromPrivateKey(privateKey, port, telemetry =
  */ export async function getBootstrapNodeEnr(privateKey, port) {
     const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
     const enr = SignableENR.createFromPeerId(peerId);
-    const listenAddrUdp = multiaddr(convertToMultiaddr(`127.0.0.1:${port}`, 'udp'));
+    const listenAddrUdp = multiaddr(convertToMultiaddr('127.0.0.1', port, 'udp'));
     enr.setLocationMultiaddr(listenAddrUdp);
     return enr;
 }

package/dest/testbench/p2p_client_testbench_worker.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=p2p_client_testbench_worker.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwX2NsaWVudF90ZXN0YmVuY2hfd29ya2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3AycF9jbGllbnRfdGVzdGJlbmNoX3dvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/testbench/p2p_client_testbench_worker.js

@@ -3,19 +3,26 @@
  *
  * Used when running testbench commands
  */ import { MockL2BlockSource } from '@aztec/archiver/test';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { openTmpStore } from '@aztec/kv-store/lmdb-v2';
-import { P2PClientType } from '@aztec/stdlib/p2p';
+import { P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
 import { Tx, TxStatus } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { TopicValidatorResult } from '@libp2p/interface';
+import EventEmitter from 'events';
 import { createP2PClient } from '../index.js';
+import { LibP2PService } from '../services/libp2p/libp2p_service.js';
 import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
 // Simple mock implementation
 function mockTxPool() {
     // Mock all methods
-    return {
-        addTxs: ()=>Promise.resolve(),
+    const pool = {
+        isEmpty: ()=>Promise.resolve(false),
+        addTxs: ()=>Promise.resolve(1),
         getTxByHash: ()=>Promise.resolve(undefined),
         getArchivedTxByHash: ()=>Promise.resolve(undefined),
         markAsMined: ()=>Promise.resolve(),
@@ -24,74 +31,156 @@ function mockTxPool() {
         getAllTxs: ()=>Promise.resolve([]),
         getAllTxHashes: ()=>Promise.resolve([]),
         getPendingTxHashes: ()=>Promise.resolve([]),
+        getPendingTxCount: ()=>Promise.resolve(0),
         getMinedTxHashes: ()=>Promise.resolve([]),
-        getTxStatus: ()=>Promise.resolve(TxStatus.PENDING)
+        getTxStatus: ()=>Promise.resolve(TxStatus.PENDING),
+        getTxsByHash: ()=>Promise.resolve([]),
+        hasTxs: ()=>Promise.resolve([]),
+        hasTx: ()=>Promise.resolve(false),
+        updateConfig: ()=>{},
+        markTxsAsNonEvictable: ()=>Promise.resolve(),
+        clearNonEvictableTxs: ()=>Promise.resolve(),
+        cleanupDeletedMinedTxs: ()=>Promise.resolve(0)
     };
+    return Object.assign(new EventEmitter(), pool);
 }
 function mockAttestationPool() {
     return {
-        addAttestations: ()=>Promise.resolve(),
-        deleteAttestations: ()=>Promise.resolve(),
-        deleteAttestationsOlderThan: ()=>Promise.resolve(),
-        deleteAttestationsForSlot: ()=>Promise.resolve(),
-        deleteAttestationsForSlotAndProposal: ()=>Promise.resolve(),
-        getAttestationsForSlot: ()=>Promise.resolve([])
+        isEmpty: ()=>Promise.resolve(false),
+        addBlockProposal: ()=>Promise.resolve(),
+        getBlockProposal: ()=>Promise.resolve(undefined),
+        hasBlockProposal: ()=>Promise.resolve(false),
+        canAddProposal: ()=>Promise.resolve(true),
+        // Checkpoint attestation methods
+        addCheckpointProposal: ()=>Promise.resolve(),
+        getCheckpointProposal: ()=>Promise.resolve(undefined),
+        hasCheckpointProposal: ()=>Promise.resolve(false),
+        addCheckpointAttestations: ()=>Promise.resolve(),
+        getCheckpointAttestationsForSlot: ()=>Promise.resolve([]),
+        getCheckpointAttestationsForSlotAndProposal: ()=>Promise.resolve([]),
+        deleteCheckpointAttestationsOlderThan: ()=>Promise.resolve(),
+        hasReachedCheckpointProposalCap: ()=>Promise.resolve(false),
+        hasReachedCheckpointAttestationCap: ()=>Promise.resolve(false),
+        canAddCheckpointProposal: ()=>Promise.resolve(true),
+        canAddCheckpointAttestation: ()=>Promise.resolve(true),
+        hasCheckpointAttestation: ()=>Promise.resolve(false)
     };
 }
 function mockEpochCache() {
     return {
-        getCommittee: ()=>Promise.resolve([]),
+        getCommittee: ()=>Promise.resolve({
+                committee: [],
+                seed: 1n,
+                epoch: EpochNumber.ZERO
+            }),
         getProposerIndexEncoding: ()=>'0x',
         getEpochAndSlotNow: ()=>({
-                epoch: 0n,
-                slot: 0n,
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
                 ts: 0n
             }),
         computeProposerIndex: ()=>0n,
-        getProposerInCurrentOrNextSlot: ()=>Promise.resolve({
+        getProposerAttesterAddressInCurrentOrNextSlot: ()=>Promise.resolve({
                 currentProposer: EthAddress.ZERO,
                 nextProposer: EthAddress.ZERO,
-                currentSlot: 0n,
-                nextSlot: 0n
+                currentSlot: SlotNumber.ZERO,
+                nextSlot: SlotNumber.ZERO
+            }),
+        getProposerAttesterAddressInSlot: ()=>Promise.resolve(undefined),
+        getEpochAndSlotInNextL1Slot: ()=>({
+                epoch: EpochNumber.ZERO,
+                slot: SlotNumber.ZERO,
+                ts: 0n,
+                now: 0n
             }),
-        isInCommittee: ()=>Promise.resolve(false)
+        isInCommittee: ()=>Promise.resolve(false),
+        getRegisteredValidators: ()=>Promise.resolve([]),
+        filterInCommittee: ()=>Promise.resolve([])
     };
 }
+function mockWorldStateSynchronizer() {
+    return {
+        status: ()=>Promise.resolve({
+                syncSummary: {
+                    latestBlockNumber: 0,
+                    latestBlockHash: '',
+                    finalizedBlockNumber: 0,
+                    treesAreSynched: false,
+                    oldestHistoricBlockNumber: 0
+                }
+            })
+    };
+}
+class TestLibP2PService extends LibP2PService {
+    disableTxValidation;
+    gossipMessageCount = 0;
+    constructor(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger = createLogger('p2p:test:libp2p_service'), disableTxValidation = true){
+        super(clientType, config, node, peerDiscoveryService, reqresp, peerManager, mempools, archiver, epochCache, proofVerifier, worldStateSynchronizer, telemetry, logger);
+        this.disableTxValidation = disableTxValidation;
+    }
+    getGossipMessageCount() {
+        return this.gossipMessageCount;
+    }
+    setDisableTxValidation(disable) {
+        this.disableTxValidation = disable;
+    }
+    async handleGossipedTx(payload, msgId, source) {
+        if (this.disableTxValidation) {
+            const p2pMessage = P2PMessage.fromMessageData(payload);
+            const tx = Tx.fromBuffer(p2pMessage.payload);
+            this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Accept);
+            const txHash = tx.getTxHash();
+            const txHashString = txHash.toString();
+            this.logger.verbose(`Received tx ${txHashString} from external peer ${source.toString()}.`);
+            await this.mempools.txPool.addTxs([
+                tx
+            ]);
+        } else {
+            await super.handleGossipedTx(payload, msgId, source);
+        }
+    }
+    async handleNewGossipMessage(msg, msgId, source) {
+        this.gossipMessageCount++;
+        process.send({
+            type: 'GOSSIP_RECEIVED',
+            count: this.gossipMessageCount
+        });
+        await super.handleNewGossipMessage(msg, msgId, source);
+    }
+}
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async (msg)=>{
-    const { type, config, clientIndex } = msg;
+    // Note: peerIdPrivateKey comes as a raw string (not SecretValue) because
+    // SecretValue's private fields can't be serialized via IPC
+    const { type, config: rawConfig, clientIndex } = msg;
     try {
         if (type === 'START') {
+            // Re-wrap the peerIdPrivateKey with SecretValue
+            const config = {
+                ...rawConfig,
+                peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined
+            };
             const txPool = mockTxPool();
             const attestationPool = mockAttestationPool();
             const epochCache = mockEpochCache();
-            const worldState = {};
+            const worldState = mockWorldStateSynchronizer();
             const l2BlockSource = new MockL2BlockSource();
-            await l2BlockSource.createBlocks(100);
             const proofVerifier = new AlwaysTrueCircuitVerifier();
             const kvStore = await openTmpStore(`test-${clientIndex}`);
             const logger = createLogger(`p2p:${clientIndex}`);
+            const telemetry = getTelemetryClient();
             const deps = {
                 txPool,
                 attestationPool,
                 store: kvStore,
                 logger
             };
-            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, undefined, deps);
-            // Create spy for gossip messages
-            let gossipMessageCount = 0;
-            client.p2pService.handleNewGossipMessage = (msg, msgId, source)=>{
-                gossipMessageCount++;
-                process.send({
-                    type: 'GOSSIP_RECEIVED',
-                    count: gossipMessageCount
-                });
-                return client.p2pService.constructor.prototype.handleNewGossipMessage.apply(client.p2pService, [
-                    msg,
-                    msgId,
-                    source
-                ]);
-            };
+            const client = await createP2PClient(P2PClientType.Full, config, l2BlockSource, proofVerifier, worldState, epochCache, 'test-p2p-bench-worker', undefined, telemetry, deps);
+            // Create test service with validation disabled
+            // Note: Parameter order must match LibP2PService constructor
+            const testService = new TestLibP2PService(P2PClientType.Full, config, client.p2pService.node, client.p2pService.peerDiscoveryService, client.p2pService.reqresp, client.p2pService.peerManager, client.p2pService.mempools, client.p2pService.archiver, epochCache, proofVerifier, worldState, telemetry, logger, true);
+            // Replace the existing p2pService with our test version
+            client.p2pService = testService;
             await client.start();
             // Wait until the client is ready
             for(let i = 0; i < 100; i++){

package/dest/testbench/parse_log_file.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=parse_log_file.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VfbG9nX2ZpbGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0YmVuY2gvcGFyc2VfbG9nX2ZpbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/testbench/parse_log_file.js

@@ -14,7 +14,7 @@ function getTimestamp(line) {
     return parseInt(timestampMatch[1], 10);
 }
 /**
- * Parses a single log line. If the line contains an "rpc.from" event,
+ * Parses a single log line. If the line contains an "Received tx" event,
  * it extracts the timestamp and the peer ID.
  */ function parseReceivedTx(line) {
     if (!line.includes('Received tx')) {
@@ -26,9 +26,9 @@ function getTimestamp(line) {
         logger.error('No timestamp found in received tx log');
         return null;
     }
-    // TODO: this is not correct - it is just the tx hash for now
-    // Extract the peer ID after "Received tx"
-    const peerIdMatch = line.match(/p2p:(\d+):/);
+    // Extract the peer ID from the log line
+    // Example format: "module":"p2p:1","msg":"Received tx 0x0feeafa65f25fd8d613fe4aca44fd65fe41c149ef1941e2019d40925c40748f9 from external peer 16Uiu2HAm8w4oxXF3TwDKoGL9U66thMXWqCgPnb2CgkYwmUqFCWbC."
+    const peerIdMatch = line.match(/"module":"p2p:(\d+)"/);
     if (!peerIdMatch) {
         logger.error('No peer Number found in received tx log');
         return null;

package/dest/testbench/testbench.d.ts

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=testbench.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdGJlbmNoLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3Rlc3RiZW5jaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dest/testbench/testbench.js

@@ -1,6 +1,6 @@
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
-import { ClientIvcProof } from '@aztec/stdlib/proofs';
+import { ChonkProof } from '@aztec/stdlib/proofs';
 import { mockTx } from '@aztec/stdlib/testing';
 import assert from 'assert';
 import path from 'path';
@@ -17,7 +17,7 @@ async function main() {
         }
         const configPath = path.join(__dirname, '../../testbench/configurations', configFile);
         const config = await import(configPath, {
-            assert: {
+            with: {
                 type: 'json'
             }
         });
@@ -34,7 +34,7 @@ async function main() {
         logger.info('Workers Ready');
         // Send tx from client 0
         const tx = await mockTx(1, {
-            clientIvcProof: ClientIvcProof.random()
+            chonkProof: ChonkProof.random()
         });
         workerClientManager.processes[0].send({
             type: 'SEND_TX',
@@ -42,7 +42,7 @@ async function main() {
         });
         logger.info('Transaction sent from client 0');
         // Give time for message propagation
-        await sleep(30000);
+        await sleep(10000);
         logger.info('Checking message propagation results');
         // Check message propagation results
         const numberOfClientsThatReceivedMessage = workerClientManager.numberOfClientsThatReceivedMessage();

package/dest/testbench/worker_client_manager.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import type { Logger } from '@aztec/foundation/log';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import { type ChildProcess } from 'child_process';
@@ -14,10 +13,6 @@ declare class WorkerClientManager {
     private messageReceivedByClient;
     constructor(logger: Logger, p2pConfig: Partial<P2PConfig>);
     destroy(): void;
-    /**
-     * Creates address strings from a port
-     */
-    private getAddresses;
     /**
      * Creates a client configuration object
      */
@@ -53,4 +48,4 @@ declare class WorkerClientManager {
     cleanup(): Promise<void>;
 }
 export { WorkerClientManager, testChainConfig };
-//# sourceMappingURL=worker_client_manager.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya2VyX2NsaWVudF9tYW5hZ2VyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGJlbmNoL3dvcmtlcl9jbGllbnRfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUV4RCxPQUFPLEVBQUUsS0FBSyxZQUFZLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFJeEQsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUF1QixNQUFNLGNBQWMsQ0FBQztBQVFuRSxRQUFBLE1BQU0sZUFBZSxFQUFFLFdBTXRCLENBQUM7QUFFRixjQUFNLG1CQUFtQjtJQUNoQixTQUFTLEVBQUUsWUFBWSxFQUFFLENBQU07SUFDL0IsaUJBQWlCLEVBQUUsTUFBTSxFQUFFLENBQU07SUFDakMsUUFBUSxFQUFFLE1BQU0sRUFBRSxDQUFNO0lBQ3hCLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBTTtJQUM1QixPQUFPLENBQUMsU0FBUyxDQUFxQjtJQUN0QyxPQUFPLENBQUMsTUFBTSxDQUFTO0lBQ3ZCLE9BQU8sQ0FBQyx1QkFBdUIsQ0FBZ0I7SUFFL0MsWUFBWSxNQUFNLEVBQUUsTUFBTSxFQUFFLFNBQVMsRUFBRSxPQUFPLENBQUMsU0FBUyxDQUFDLEVBR3hEO0lBRUQsT0FBTyxTQUtOO0lBRUQ7O09BRUc7SUFDSCxPQUFPLENBQUMsa0JBQWtCO0lBaUIxQjs7T0FFRztJQUNILE9BQU8sQ0FBQyxrQkFBa0I7SUF5RDFCOzs7Ozs7T0FNRztJQUNHLGlCQUFpQixDQUFDLGVBQWUsRUFBRSxNQUFNLHFCQXlDOUM7SUFFRCw0QkFBNEIsU0FFM0I7SUFFRCxrQ0FBa0MsV0FFakM7SUFFRDs7Ozs7T0FLRztJQUNHLFVBQVUsQ0FBQyxXQUFXLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQTRDcEQ7SUFFRDs7T0FFRztJQUNILE9BQU8sQ0FBQyxnQkFBZ0I7SUFzQ3hCOztPQUVHO0lBQ0csT0FBTyxrQkFnQ1o7Q0FDRjtBQUVELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxlQUFlLEVBQUUsQ0FBQyJ9

package/dest/testbench/worker_client_manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAQnE,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,cAAM,mBAAmB;IAChB,SAAS,EAAE,YAAY,EAAE,CAAM;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,MAAM,EAAE,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;gBAEnC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;IAKzD,OAAO;IAOP;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAoD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM;IA2C/C,4BAA4B;IAI5B,kCAAkC;IAIlC;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IA4CrD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO;CAiCd;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"worker_client_manager.d.ts","sourceRoot":"","sources":["../../src/testbench/worker_client_manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,EAAE,KAAK,YAAY,EAAQ,MAAM,eAAe,CAAC;AAIxD,OAAO,EAAE,KAAK,SAAS,EAAuB,MAAM,cAAc,CAAC;AAQnE,QAAA,MAAM,eAAe,EAAE,WAMtB,CAAC;AAEF,cAAM,mBAAmB;IAChB,SAAS,EAAE,YAAY,EAAE,CAAM;IAC/B,iBAAiB,EAAE,MAAM,EAAE,CAAM;IACjC,QAAQ,EAAE,MAAM,EAAE,CAAM;IACxB,KAAK,EAAE,MAAM,EAAE,CAAM;IAC5B,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,uBAAuB,CAAgB;IAE/C,YAAY,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,EAGxD;IAED,OAAO,SAKN;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAiB1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyD1B;;;;;;OAMG;IACG,iBAAiB,CAAC,eAAe,EAAE,MAAM,qBAyC9C;IAED,4BAA4B,SAE3B;IAED,kCAAkC,WAEjC;IAED;;;;;OAKG;IACG,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBA4CpD;IAED;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsCxB;;OAEG;IACG,OAAO,kBAgCZ;CACF;AAED,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,CAAC"}

package/dest/testbench/worker_client_manager.js

@@ -1,3 +1,4 @@
+import { SecretValue } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { sleep } from '@aztec/foundation/sleep';
 import { fork } from 'child_process';
@@ -11,7 +12,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const workerPath = path.join(__dirname, '../../dest/testbench/p2p_client_testbench_worker.js');
 const testChainConfig = {
     l1ChainId: 31337,
-    version: 1,
+    rollupVersion: 1,
     l1Contracts: {
         rollupAddress: EthAddress.random()
     }
@@ -35,25 +36,15 @@ class WorkerClientManager {
         });
     }
     /**
-   * Creates address strings from a port
-   */ getAddresses(port) {
-        return {
-            addr: `127.0.0.1:${port}`,
-            listenAddr: `0.0.0.0:${port}`
-        };
-    }
-    /**
    * Creates a client configuration object
    */ createClientConfig(clientIndex, port, otherNodes) {
-        const { addr, listenAddr } = this.getAddresses(port);
         return {
             ...getP2PDefaultConfig(),
             p2pEnabled: true,
-            peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
-            tcpListenAddress: listenAddr,
-            udpListenAddress: listenAddr,
-            tcpAnnounceAddress: addr,
-            udpAnnounceAddress: addr,
+            peerIdPrivateKey: new SecretValue(this.peerIdPrivateKeys[clientIndex]),
+            listenAddress: '127.0.0.1',
+            p2pIp: '127.0.0.1',
+            p2pPort: port,
             bootstrapNodes: [
                 ...otherNodes
             ],
@@ -64,9 +55,14 @@ class WorkerClientManager {
    * Spawns a worker process and returns a promise that resolves when the worker is ready
    */ spawnWorkerProcess(config, clientIndex) {
         const childProcess = fork(workerPath);
+        // Extract the raw peerIdPrivateKey value since SecretValue can't be serialized via IPC
+        const serializedConfig = {
+            ...config,
+            peerIdPrivateKey: config.peerIdPrivateKey?.getValue()
+        };
         childProcess.send({
             type: 'START',
-            config,
+            config: serializedConfig,
             clientIndex
         });
         // Handle unexpected child process exit
@@ -177,6 +173,7 @@ class WorkerClientManager {
             this.peerEnrs[clientIndex] = await makeEnr(this.peerIdPrivateKeys[clientIndex], newPort, testChainConfig);
             // Maximum seed with 10 other peers to allow peer discovery to connect them at a smoother rate
             const otherNodes = this.peerEnrs.filter((_, ind)=>ind !== clientIndex && ind < Math.min(this.peerEnrs.length, 10));
+            this.logger.info(`Changing port for client ${clientIndex} to ${newPort} with other nodes `, otherNodes);
             const config = this.createClientConfig(clientIndex, newPort, otherNodes);
             const [childProcess, readySignal] = this.spawnWorkerProcess(config, clientIndex);
             this.processes[clientIndex] = childProcess;
@@ -207,7 +204,7 @@ class WorkerClientManager {
                 } catch (e) {
                     this.logger.error(`Error force killing process ${index}:`, e);
                 }
-            }, 10000); // 10 second timeout for graceful exit
+            }, 5000); // 5 second timeout for graceful exit
             // Listen for process exit
             process1.once('exit', ()=>{
                 clearTimeout(forceKillTimeout);
@@ -218,7 +215,7 @@ class WorkerClientManager {
                 process1.send({
                     type: 'STOP'
                 });
-            } catch (e) {
+            } catch  {
                 // If sending the message fails, force kill immediately
                 clearTimeout(forceKillTimeout);
                 try {
@@ -248,12 +245,12 @@ class WorkerClientManager {
                                 if (!p.killed) {
                                     p.kill('SIGKILL');
                                 }
-                            } catch (e) {
+                            } catch  {
                             // Ignore errors when force killing
                             }
                         });
                         resolve();
-                    }, 30000); // 30 second timeout for all processes
+                    }, 10000); // 10 second timeout for all processes
                 })
             ]);
         } catch (error) {

package/dest/types/index.d.ts

@@ -14,7 +14,8 @@ export declare enum PeerEvent {
  */
 export declare enum Discv5Event {
     DISCOVERED = "discovered",
-    ENR_ADDED = "enrAdded"
+    ENR_ADDED = "enrAdded",
+    MULTIADDR_UPDATED = "multiaddrUpdated"
 }
 /**
  * Events emitted from the GossipSub protocol.
@@ -29,4 +30,5 @@ export declare enum GossipSubEvent {
  * Aztec network specific types
  */
 export declare const AZTEC_ENR_KEY = "aztec";
-//# sourceMappingURL=index.d.ts.map
+export declare const AZTEC_ENR_CLIENT_VERSION_KEY = "ver";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7cURBRXFEO0FBRXJEOztHQUVHO0FBQ0gsb0JBQVksU0FBUztJQUNuQixVQUFVLG9CQUFvQjtJQUM5QixTQUFTLGlCQUFpQjtJQUMxQixZQUFZLG9CQUFvQjtDQUNqQztBQUVEOztHQUVHO0FBQ0gsb0JBQVksV0FBVztJQUNyQixVQUFVLGVBQWU7SUFDekIsU0FBUyxhQUFhO0lBQ3RCLGlCQUFpQixxQkFBcUI7Q0FDdkM7QUFFRDs7R0FFRztBQUNILG9CQUFZLGNBQWM7SUFDeEIsT0FBTyxzQkFBc0I7Q0FDOUI7QUFFRDs7cURBRXFEO0FBRXJEOztHQUVHO0FBQ0gsZUFBTyxNQUFNLGFBQWEsVUFBVSxDQUFDO0FBQ3JDLGVBQU8sTUFBTSw0QkFBNEIsUUFBUSxDQUFDIn0=

package/dest/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;qDAEqD;AAErD;;GAEG;AACH,oBAAY,SAAS;IACnB,UAAU,oBAAoB;IAC9B,SAAS,iBAAiB;IAC1B,YAAY,oBAAoB;CACjC;AAED;;GAEG;AACH,oBAAY,WAAW;IACrB,UAAU,eAAe;IACzB,SAAS,aAAa;CACvB;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,OAAO,sBAAsB;CAC9B;AAED;;qDAEqD;AAErD;;GAEG;AACH,eAAO,MAAM,aAAa,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;qDAEqD;AAErD;;GAEG;AACH,oBAAY,SAAS;IACnB,UAAU,oBAAoB;IAC9B,SAAS,iBAAiB;IAC1B,YAAY,oBAAoB;CACjC;AAED;;GAEG;AACH,oBAAY,WAAW;IACrB,UAAU,eAAe;IACzB,SAAS,aAAa;IACtB,iBAAiB,qBAAqB;CACvC;AAED;;GAEG;AACH,oBAAY,cAAc;IACxB,OAAO,sBAAsB;CAC9B;AAED;;qDAEqD;AAErD;;GAEG;AACH,eAAO,MAAM,aAAa,UAAU,CAAC;AACrC,eAAO,MAAM,4BAA4B,QAAQ,CAAC"}