@aztec/p2p 0.0.1-commit.f2ce05ee → 0.0.1-commit.f81dbcf

package/src/testbench/p2p_client_testbench_worker.ts

@@ -19,7 +19,7 @@ import { protocolContractsHash } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
 import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { type BlockProposal, P2PClientType, P2PMessage } from '@aztec/stdlib/p2p';
+import { type BlockProposal, P2PMessage } from '@aztec/stdlib/p2p';
 import { ChonkProof } from '@aztec/stdlib/proofs';
 import { makeAztecAddress, makeBlockHeader, makeBlockProposal, mockTx } from '@aztec/stdlib/testing';
 import { Tx, TxHash, type TxValidationResult } from '@aztec/stdlib/tx';
@@ -29,22 +29,19 @@ import type { Message, PeerId } from '@libp2p/interface';
 import { TopicValidatorResult } from '@libp2p/interface';
 import { peerIdFromString } from '@libp2p/peer-id';
 
-import type { P2PClient } from '../client/p2p_client.js';
+import type { P2PClient } from '../client/index.js';
 import type { P2PConfig } from '../config.js';
 import { createP2PClient } from '../index.js';
-import type { MemPools } from '../mem_pools/interface.js';
-import { LibP2PService } from '../services/libp2p/libp2p_service.js';
+import type { MemPools } from '../mem_pools/index.js';
+import { BatchTxRequesterCollector, LibP2PService, SendBatchRequestCollector } from '../services/index.js';
 import type { PeerManager } from '../services/peer-manager/peer_manager.js';
 import type { BatchTxRequesterLibP2PService } from '../services/reqresp/batch-tx-requester/interface.js';
 import type { IBatchRequestTxValidator } from '../services/reqresp/batch-tx-requester/tx_validator.js';
 import { RateLimitStatus } from '../services/reqresp/rate-limiter/rate_limiter.js';
 import type { ReqResp } from '../services/reqresp/reqresp.js';
 import type { PeerDiscoveryService } from '../services/service.js';
-import {
-  BatchTxRequesterCollector,
-  SendBatchRequestCollector,
-} from '../services/tx_collection/proposal_tx_collector.js';
-import { AlwaysTrueCircuitVerifier } from '../test-helpers/reqresp-nodes.js';
+import { MissingTxsTracker } from '../services/tx_collection/missing_txs_tracker.js';
+import { AlwaysTrueCircuitVerifier } from '../test-helpers/index.js';
 import {
   BENCHMARK_CONSTANTS,
   type CollectorType,
@@ -55,7 +52,7 @@ import {
   createMockEpochCache,
   createMockWorldStateSynchronizer,
   filterTxsByDistribution,
-} from '../test-helpers/testbench-utils.js';
+} from '../test-helpers/index.js';
 import type { PubSubLibp2p } from '../util.js';
 
 export type { DistributionPattern, CollectorType } from '../test-helpers/testbench-utils.js';
@@ -89,12 +86,11 @@ export interface BenchReadyMessage {
 }
 const txCache = new Map<number, Tx[]>();
 
-class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends LibP2PService<T> {
+class TestLibP2PService extends LibP2PService {
   private disableTxValidation: boolean;
   private gossipMessageCount = 0;
 
   constructor(
-    clientType: T,
     config: P2PConfig,
     node: PubSubLibp2p,
     peerDiscoveryService: PeerDiscoveryService,
@@ -110,7 +106,6 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
     disableTxValidation = true,
   ) {
     super(
-      clientType,
       config,
       node,
       peerDiscoveryService,
@@ -144,7 +139,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
       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]);
+      await this.mempools.txPool.addPendingTxs([tx]);
     } else {
       await super.handleGossipedTx(payload, msgId, source);
     }
@@ -166,7 +161,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
     return cached.slice(0, txCount);
   }
 
-  const includeByTimestampBase = BigInt(seed);
+  const expirationTimestampBase = BigInt(seed);
   for (let i = cached.length; i < txCount; i++) {
     const txSeed = seed * 10000 + i;
     const tx = await mockTx(txSeed, {
@@ -182,7 +177,7 @@ async function generateDeterministicTxs(txCount: number, seed: number, config: P
       hasPublicTeardownCallRequest: false,
       publicCalldataSize: 0,
     });
-    tx.data.includeByTimestamp = includeByTimestampBase + BigInt(i);
+    tx.data.expirationTimestamp = expirationTimestampBase + BigInt(i);
     await tx.recomputeHash();
     cached.push(tx);
   }
@@ -277,7 +272,12 @@ async function runAggregatorBenchmark(
         new DateProvider(),
         noopTxValidator,
       );
-      const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+      const fetchedTxs = await collector.collectTxs(
+        MissingTxsTracker.fromArray(txHashes),
+        blockProposal,
+        pinnedPeer,
+        timeoutMs,
+      );
       const durationMs = timer.ms();
       return {
         type: 'BENCH_RESULT',
@@ -292,7 +292,12 @@ async function runAggregatorBenchmark(
       BENCHMARK_CONSTANTS.FIXED_MAX_PEERS,
       BENCHMARK_CONSTANTS.FIXED_MAX_RETRY_ATTEMPTS,
     );
-    const fetchedTxs = await collector.collectTxs(txHashes, blockProposal, pinnedPeer, timeoutMs);
+    const fetchedTxs = await collector.collectTxs(
+      MissingTxsTracker.fromArray(txHashes),
+      blockProposal,
+      pinnedPeer,
+      timeoutMs,
+    );
     const durationMs = timer.ms();
     return {
       type: 'BENCH_RESULT',
@@ -335,6 +340,7 @@ process.on('message', async msg => {
       const config: P2PConfig = {
         ...rawConfig,
         peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+        priceBumpPercentage: 10n,
       } as P2PConfig;
 
       workerConfig = config;
@@ -358,7 +364,6 @@ process.on('message', async msg => {
       };
 
       const client = await createP2PClient(
-        P2PClientType.Full,
         config as P2PConfig & DataStoreConfig,
         l2BlockSource,
         proofVerifier as ClientProtocolCircuitVerifier,
@@ -371,7 +376,6 @@ process.on('message', async msg => {
       );
 
       const testService = new TestLibP2PService(
-        P2PClientType.Full,
         config,
         (client as any).p2pService.node,
         (client as any).p2pService.peerDiscoveryService,

package/src/testbench/worker_client_manager.ts

@@ -81,13 +81,15 @@ class WorkerClientManager {
    * Note: We send the raw peerIdPrivateKey string instead of SecretValue
    * because SecretValue.toJSON() returns '[Redacted]', losing the value.
    * The worker must re-wrap it in SecretValue.
+   * We also omit priceBumpPercentage since it's a bigint and can't be
+   * serialized over IPC (which uses JSON under the hood).
    */
   private createClientConfig(
     clientIndex: number,
     port: number,
     otherNodes: string[],
-  ): Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig> {
-    return {
+  ): Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & { peerIdPrivateKey: string } & Partial<ChainConfig> {
+    const { priceBumpPercentage: _, ...config } = {
       ...getP2PDefaultConfig(),
       p2pEnabled: true,
       peerIdPrivateKey: this.peerIdPrivateKeys[clientIndex],
@@ -96,7 +98,10 @@ class WorkerClientManager {
       p2pPort: port,
       bootstrapNodes: [...otherNodes],
       ...this.p2pConfig,
-    } as Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig>;
+    };
+    return config as Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & {
+      peerIdPrivateKey: string;
+    } & Partial<ChainConfig>;
   }
 
   /**
@@ -104,7 +109,9 @@ class WorkerClientManager {
    * Config uses raw string for peerIdPrivateKey (not SecretValue) for IPC serialization.
    */
   private spawnWorkerProcess(
-    config: Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey: string } & Partial<ChainConfig>,
+    config: Omit<P2PConfig, 'peerIdPrivateKey' | 'priceBumpPercentage'> & {
+      peerIdPrivateKey: string;
+    } & Partial<ChainConfig>,
     clientIndex: number,
   ): [ChildProcess, Promise<void>] {
     const useCompiled = existsSync(workerJsPath);

package/src/util.ts

@@ -23,7 +23,13 @@ export interface PubSubLibp2p extends Pick<Libp2p, 'status' | 'start' | 'stop' |
   services: {
     pubsub: Pick<
       GossipSub,
-      'addEventListener' | 'removeEventListener' | 'publish' | 'subscribe' | 'reportMessageValidationResult' | 'direct'
+      | 'addEventListener'
+      | 'removeEventListener'
+      | 'publish'
+      | 'subscribe'
+      | 'reportMessageValidationResult'
+      | 'direct'
+      | 'getMeshPeers'
     > & { score: Pick<GossipSub['score'], 'score'> };
   };
 }

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts

@@ -1,23 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import { type BlockProposal, type CheckpointProposal, type ValidationResult } from '@aztec/stdlib/p2p';
-import type { TxHash } from '@aztec/stdlib/tx';
-import type { MockProxy } from 'jest-mock-extended';
-export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
-    validatorFactory: (epochCache: EpochCacheInterface, opts: {
-        txsPermitted: boolean;
-    }) => {
-        validate: (proposal: TProposal) => Promise<ValidationResult>;
-    };
-    makeProposal: (options?: any) => Promise<TProposal>;
-    makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
-    getSigner: () => Secp256k1Signer;
-    getAddress: (signer?: Secp256k1Signer) => EthAddress;
-    getSlot: (slot: number | bigint) => any;
-    getTxHashes: (n: number) => TxHash[];
-    getTxs: () => any[];
-    epochCacheMock: () => MockProxy<EpochCacheInterface>;
-}
-export declare function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(params: ProposalValidatorTestParams<TProposal>): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9wcm9wb3NhbF92YWxpZGF0b3IvcHJvcG9zYWxfdmFsaWRhdG9yX3Rlc3Rfc3VpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUNoRSxPQUFPLEVBQ0wsS0FBSyxhQUFhLEVBQ2xCLEtBQUssa0JBQWtCLEVBRXZCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sbUJBQW1CLENBQUM7QUFDM0IsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFL0MsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFcEQsTUFBTSxXQUFXLDJCQUEyQixDQUFDLFNBQVMsU0FBUyxhQUFhLEdBQUcsa0JBQWtCO0lBQy9GLGdCQUFnQixFQUFFLENBQ2hCLFVBQVUsRUFBRSxtQkFBbUIsRUFDL0IsSUFBSSxFQUFFO1FBQUUsWUFBWSxFQUFFLE9BQU8sQ0FBQTtLQUFFLEtBQzVCO1FBQUUsUUFBUSxFQUFFLENBQUMsUUFBUSxFQUFFLFNBQVMsS0FBSyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQTtLQUFFLENBQUM7SUFDdEUsWUFBWSxFQUFFLENBQUMsT0FBTyxDQUFDLEVBQUUsR0FBRyxLQUFLLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNwRCxVQUFVLEVBQUUsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxVQUFVLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sS0FBSyxHQUFHLENBQUM7SUFDN0csU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0lBQ2pDLFVBQVUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxFQUFFLGVBQWUsS0FBSyxVQUFVLENBQUM7SUFDckQsT0FBTyxFQUFFLENBQUMsSUFBSSxFQUFFLE1BQU0sR0FBRyxNQUFNLEtBQUssR0FBRyxDQUFDO0lBQ3hDLFdBQVcsRUFBRSxDQUFDLENBQUMsRUFBRSxNQUFNLEtBQUssTUFBTSxFQUFFLENBQUM7SUFDckMsTUFBTSxFQUFFLE1BQU0sR0FBRyxFQUFFLENBQUM7SUFDcEIsY0FBYyxFQUFFLE1BQU0sU0FBUyxDQUFDLG1CQUFtQixDQUFDLENBQUM7Q0FDdEQ7QUFFRCx3QkFBZ0IsNEJBQTRCLENBQUMsU0FBUyxTQUFTLGFBQWEsR0FBRyxrQkFBa0IsRUFDL0YsTUFBTSxFQUFFLDJCQUEyQixDQUFDLFNBQVMsQ0FBQyxRQXdNL0MifQ==

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"proposal_validator_test_suite.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/proposal_validator/proposal_validator_test_suite.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,kBAAkB,EAEvB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,MAAM,WAAW,2BAA2B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB;IAC/F,gBAAgB,EAAE,CAChB,UAAU,EAAE,mBAAmB,EAC/B,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE,KAC5B;QAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAA;KAAE,CAAC;IACtE,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACpD,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IAC7G,SAAS,EAAE,MAAM,eAAe,CAAC;IACjC,UAAU,EAAE,CAAC,MAAM,CAAC,EAAE,eAAe,KAAK,UAAU,CAAC;IACrD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,KAAK,GAAG,CAAC;IACxC,WAAW,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IACrC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,SAAS,CAAC,mBAAmB,CAAC,CAAC;CACtD;AAED,wBAAgB,4BAA4B,CAAC,SAAS,SAAS,aAAa,GAAG,kBAAkB,EAC/F,MAAM,EAAE,2BAA2B,CAAC,SAAS,CAAC,QAwM/C"}

package/dest/msg_validators/proposal_validator/proposal_validator_test_suite.js

@@ -1,212 +0,0 @@
-import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export function sharedProposalValidatorTests(params) {
-    const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } = params;
-    describe('shared proposal validation logic', ()=>{
-        let epochCache;
-        let validator;
-        const previousSlot = getSlot(99);
-        const currentSlot = getSlot(100);
-        const nextSlot = getSlot(101);
-        function mockGetProposer(currentProposer, nextProposer, previousProposer) {
-            epochCache.getProposerAttesterAddressInSlot.mockImplementation((slot)=>{
-                if (slot === currentSlot) {
-                    return Promise.resolve(currentProposer);
-                }
-                if (slot === nextSlot) {
-                    return Promise.resolve(nextProposer);
-                }
-                if (slot === previousSlot && previousProposer) {
-                    return Promise.resolve(previousProposer);
-                }
-                throw new Error('Unexpected argument');
-            });
-        }
-        beforeEach(()=>{
-            epochCache = epochCacheMock();
-            validator = validatorFactory(epochCache, {
-                txsPermitted: true
-            });
-            epochCache.getCurrentAndNextSlot.mockReturnValue({
-                currentSlot: currentSlot,
-                nextSlot: nextSlot
-            });
-        });
-        it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async ()=>{
-            const header = makeHeader(1, 99, 99);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header
-            });
-            // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
-            epochCache.getEpochAndSlotNow.mockReturnValue({
-                epoch: 1,
-                slot: currentSlot,
-                ts: 1000n,
-                nowMs: 1001000n
-            });
-            epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'reject',
-                severity: PeerErrorSeverity.HighToleranceError
-            });
-            // Should not try to resolve proposers if base validation fails
-            expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
-        });
-        it('returns ignore if previous slot proposal is within clock tolerance', async ()=>{
-            const previousProposer = getSigner();
-            const header = makeHeader(1, 99, 99);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: previousProposer
-            });
-            // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
-            epochCache.getEpochAndSlotNow.mockReturnValue({
-                epoch: 1,
-                slot: currentSlot,
-                ts: 1000n,
-                nowMs: 1000100n
-            });
-            mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'ignore'
-            });
-        });
-        it('returns mid tolerance error if proposer is not current proposer for current slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const invalidProposer = getSigner();
-            const header = makeHeader(1, 100, 100);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: invalidProposer
-            });
-            mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'reject',
-                severity: PeerErrorSeverity.MidToleranceError
-            });
-        });
-        it('returns mid tolerance error if proposer is not next proposer for next slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const invalidProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: invalidProposer
-            });
-            mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'reject',
-                severity: PeerErrorSeverity.MidToleranceError
-            });
-        });
-        it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: currentProposer
-            });
-            mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'reject',
-                severity: PeerErrorSeverity.MidToleranceError
-            });
-        });
-        it('returns undefined if proposal is valid for current slot and proposer', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 100, 100);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: currentProposer
-            });
-            mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'accept'
-            });
-        });
-        it('returns undefined if proposal is valid for next slot and proposer', async ()=>{
-            const currentProposer = getSigner();
-            const nextProposer = getSigner();
-            const header = makeHeader(1, 101, 101);
-            const mockProposal = await makeProposal({
-                blockHeader: header,
-                lastBlockHeader: header,
-                signer: nextProposer
-            });
-            mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-            const result = await validator.validate(mockProposal);
-            expect(result).toEqual({
-                result: 'accept'
-            });
-        });
-        describe('transaction permission validation', ()=>{
-            it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const validatorWithTxsDisabled = validatorFactory(epochCache, {
-                    txsPermitted: false
-                });
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(2)
-                });
-                mockGetProposer(getAddress(currentProposer), getAddress());
-                const result = await validatorWithTxsDisabled.validate(mockProposal);
-                expect(result).toEqual({
-                    result: 'reject',
-                    severity: PeerErrorSeverity.MidToleranceError
-                });
-            });
-            it('returns undefined if txs not permitted but proposal has no txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const validatorWithTxsDisabled = validatorFactory(epochCache, {
-                    txsPermitted: false
-                });
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(0)
-                });
-                mockGetProposer(getAddress(currentProposer), getAddress());
-                const result = await validatorWithTxsDisabled.validate(mockProposal);
-                expect(result).toEqual({
-                    result: 'accept'
-                });
-            });
-            it('returns undefined if txs permitted and proposal contains txHashes', async ()=>{
-                const currentProposer = getSigner();
-                const header = makeHeader(1, 100, 100);
-                const mockProposal = await makeProposal({
-                    blockHeader: header,
-                    lastBlockHeader: header,
-                    signer: currentProposer,
-                    txHashes: getTxHashes(2)
-                });
-                mockGetProposer(getAddress(currentProposer), getAddress());
-                const result = await validator.validate(mockProposal);
-                expect(result).toEqual({
-                    result: 'accept'
-                });
-            });
-        });
-    });
-}

package/src/msg_validators/proposal_validator/proposal_validator_test_suite.ts

@@ -1,230 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import {
-  type BlockProposal,
-  type CheckpointProposal,
-  PeerErrorSeverity,
-  type ValidationResult,
-} from '@aztec/stdlib/p2p';
-import type { TxHash } from '@aztec/stdlib/tx';
-
-import type { MockProxy } from 'jest-mock-extended';
-
-export interface ProposalValidatorTestParams<TProposal extends BlockProposal | CheckpointProposal> {
-  validatorFactory: (
-    epochCache: EpochCacheInterface,
-    opts: { txsPermitted: boolean },
-  ) => { validate: (proposal: TProposal) => Promise<ValidationResult> };
-  makeProposal: (options?: any) => Promise<TProposal>;
-  makeHeader: (epochNumber: number | bigint, slotNumber: number | bigint, blockNumber: number | bigint) => any;
-  getSigner: () => Secp256k1Signer;
-  getAddress: (signer?: Secp256k1Signer) => EthAddress;
-  getSlot: (slot: number | bigint) => any;
-  getTxHashes: (n: number) => TxHash[];
-  getTxs: () => any[];
-  epochCacheMock: () => MockProxy<EpochCacheInterface>;
-}
-
-export function sharedProposalValidatorTests<TProposal extends BlockProposal | CheckpointProposal>(
-  params: ProposalValidatorTestParams<TProposal>,
-) {
-  const { validatorFactory, makeProposal, makeHeader, getSigner, getAddress, getSlot, getTxHashes, epochCacheMock } =
-    params;
-
-  describe('shared proposal validation logic', () => {
-    let epochCache: MockProxy<EpochCacheInterface>;
-    let validator: { validate: (proposal: TProposal) => Promise<ValidationResult> };
-    const previousSlot = getSlot(99);
-    const currentSlot = getSlot(100);
-    const nextSlot = getSlot(101);
-
-    function mockGetProposer(currentProposer: EthAddress, nextProposer: EthAddress, previousProposer?: EthAddress) {
-      epochCache.getProposerAttesterAddressInSlot.mockImplementation(slot => {
-        if (slot === currentSlot) {
-          return Promise.resolve(currentProposer);
-        }
-        if (slot === nextSlot) {
-          return Promise.resolve(nextProposer);
-        }
-        if (slot === previousSlot && previousProposer) {
-          return Promise.resolve(previousProposer);
-        }
-        throw new Error('Unexpected argument');
-      });
-    }
-
-    beforeEach(() => {
-      epochCache = epochCacheMock();
-      validator = validatorFactory(epochCache, { txsPermitted: true });
-      epochCache.getCurrentAndNextSlot.mockReturnValue({
-        currentSlot: currentSlot,
-        nextSlot: nextSlot,
-      });
-    });
-
-    it('returns high tolerance error if slot number is not current or next slot (outside clock tolerance)', async () => {
-      const header = makeHeader(1, 99, 99);
-      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header });
-
-      // Mock getEpochAndSlotNow to return time OUTSIDE clock tolerance (1000ms elapsed)
-      epochCache.getEpochAndSlotNow.mockReturnValue({
-        epoch: 1 as any,
-        slot: currentSlot,
-        ts: 1000n, // slot started at 1000 seconds
-        nowMs: 1001000n, // 1000ms elapsed, outside 500ms tolerance
-      });
-
-      epochCache.getProposerAttesterAddressInSlot.mockResolvedValue(getAddress());
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.HighToleranceError });
-
-      // Should not try to resolve proposers if base validation fails
-      expect(epochCache.getProposerAttesterAddressInSlot).not.toHaveBeenCalled();
-    });
-
-    it('returns ignore if previous slot proposal is within clock tolerance', async () => {
-      const previousProposer = getSigner();
-      const header = makeHeader(1, 99, 99);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: previousProposer,
-      });
-
-      // Mock getEpochAndSlotNow to return time WITHIN clock tolerance (100ms elapsed)
-      epochCache.getEpochAndSlotNow.mockReturnValue({
-        epoch: 1 as any,
-        slot: currentSlot,
-        ts: 1000n, // slot started at 1000 seconds
-        nowMs: 1000100n, // 100ms elapsed, within 500ms tolerance
-      });
-
-      mockGetProposer(getAddress(), getAddress(), getAddress(previousProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'ignore' });
-    });
-
-    it('returns mid tolerance error if proposer is not current proposer for current slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const invalidProposer = getSigner();
-      const header = makeHeader(1, 100, 100);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: invalidProposer,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
-    });
-
-    it('returns mid tolerance error if proposer is not next proposer for next slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const invalidProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: invalidProposer,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
-    });
-
-    it('returns mid tolerance error if proposer is current proposer but proposal is for next slot', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: currentProposer,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
-    });
-
-    it('returns undefined if proposal is valid for current slot and proposer', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 100, 100);
-      const mockProposal = await makeProposal({
-        blockHeader: header,
-        lastBlockHeader: header,
-        signer: currentProposer,
-      });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'accept' });
-    });
-
-    it('returns undefined if proposal is valid for next slot and proposer', async () => {
-      const currentProposer = getSigner();
-      const nextProposer = getSigner();
-      const header = makeHeader(1, 101, 101);
-      const mockProposal = await makeProposal({ blockHeader: header, lastBlockHeader: header, signer: nextProposer });
-
-      mockGetProposer(getAddress(currentProposer), getAddress(nextProposer));
-      const result = await validator.validate(mockProposal);
-      expect(result).toEqual({ result: 'accept' });
-    });
-
-    describe('transaction permission validation', () => {
-      it('returns mid tolerance error if txs not permitted and proposal contains txHashes', async () => {
-        const currentProposer = getSigner();
-        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(2),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toEqual({ result: 'reject', severity: PeerErrorSeverity.MidToleranceError });
-      });
-
-      it('returns undefined if txs not permitted but proposal has no txHashes', async () => {
-        const currentProposer = getSigner();
-        const validatorWithTxsDisabled = validatorFactory(epochCache, { txsPermitted: false });
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(0),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validatorWithTxsDisabled.validate(mockProposal);
-        expect(result).toEqual({ result: 'accept' });
-      });
-
-      it('returns undefined if txs permitted and proposal contains txHashes', async () => {
-        const currentProposer = getSigner();
-        const header = makeHeader(1, 100, 100);
-        const mockProposal = await makeProposal({
-          blockHeader: header,
-          lastBlockHeader: header,
-          signer: currentProposer,
-          txHashes: getTxHashes(2),
-        });
-
-        mockGetProposer(getAddress(currentProposer), getAddress());
-        const result = await validator.validate(mockProposal);
-        expect(result).toEqual({ result: 'accept' });
-      });
-    });
-  });
-}