@aztec/p2p 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/dest/mem_pools/tx_pool/tx_pool_test_suite.js

@@ -1,38 +1,91 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { unfreeze } from '@aztec/foundation/types';
 import { GasFees } from '@aztec/stdlib/gas';
 import { mockTx } from '@aztec/stdlib/testing';
+import { BlockHeader, GlobalVariables } from '@aztec/stdlib/tx';
 /**
  * Tests a TxPool implementation.
  * @param getTxPool - Gets a fresh TxPool
  */ export function describeTxPool(getTxPool) {
     let pool;
+    const minedBlockHeader = BlockHeader.empty({
+        globalVariables: GlobalVariables.empty({
+            blockNumber: BlockNumber(1),
+            timestamp: 0n
+        })
+    });
     beforeEach(()=>{
         pool = getTxPool();
     });
-    it('Adds txs to the pool as pending', async ()=>{
-        const tx1 = await mockTx();
+    afterEach(()=>{
+        pool.removeAllListeners('txs-added');
+    });
+    it('adds txs to the pool as pending', async ()=>{
+        const tx1 = await mockTx(1);
         await pool.addTxs([
             tx1
         ]);
-        const poolTx = await pool.getTxByHash(await tx1.getTxHash());
-        expect(await poolTx.getTxHash()).toEqual(await tx1.getTxHash());
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
+        const poolTx = await pool.getTxByHash(tx1.getTxHash());
+        expect(poolTx.getTxHash()).toEqual(tx1.getTxHash());
+        await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('pending');
         await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            await tx1.getTxHash()
+            tx1.getTxHash()
         ]);
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Removes txs from the pool', async ()=>{
-        const tx1 = await mockTx();
+    it('emits txs-added event with new txs', async ()=>{
+        const tx1 = await mockTx(1); // existing and pending
+        const tx2 = await mockTx(2); // mined but not known
+        const tx3 = await mockTx(3); // brand new
         await pool.addTxs([
             tx1
         ]);
+        await pool.markAsMined([
+            tx2.getTxHash()
+        ], minedBlockHeader);
+        let txsFromEvent = undefined;
+        pool.once('txs-added', ({ txs })=>{
+            txsFromEvent = txs;
+        });
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3
+        ]);
+        expect(txsFromEvent).toBeDefined();
+        expect(txsFromEvent).toHaveLength(2);
+        const eventHashes = txsFromEvent.map((tx)=>tx.getTxHash());
+        expect(eventHashes).toEqual(expect.arrayContaining([
+            tx2.getTxHash(),
+            tx3.getTxHash()
+        ]));
+    });
+    it('removes txs from the pool', async ()=>{
+        const pendingTx = await mockTx(1);
+        const minedTx = await mockTx(2);
+        await pool.addTxs([
+            pendingTx,
+            minedTx
+        ]);
+        await pool.markAsMined([
+            minedTx.getTxHash()
+        ], minedBlockHeader);
+        // Delete a pending tx - should be permanently deleted
+        await pool.deleteTxs([
+            pendingTx.getTxHash()
+        ]);
+        await expect(pool.getTxByHash(pendingTx.getTxHash())).resolves.toBeUndefined();
+        await expect(pool.getTxStatus(pendingTx.getTxHash())).resolves.toBeUndefined();
+        // Delete a mined tx - should be soft-deleted (still in storage)
         await pool.deleteTxs([
-            await tx1.getTxHash()
+            minedTx.getTxHash()
         ]);
-        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
+        await expect(pool.getTxByHash(minedTx.getTxHash())).resolves.toBeDefined();
+        await expect(pool.getTxStatus(minedTx.getTxHash())).resolves.toEqual('deleted');
+        await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
+        await expect(pool.getPendingTxCount()).resolves.toEqual(0);
     });
-    it('Marks txs as mined', async ()=>{
+    it('marks txs as mined', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         await pool.addTxs([
@@ -40,21 +93,23 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2
         ]);
         await pool.markAsMined([
-            await tx1.getTxHash()
-        ], 1);
-        await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-        await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
+            tx1.getTxHash()
+        ], minedBlockHeader);
+        const retrievedTx = await pool.getTxByHash(tx1.getTxHash());
+        expect(retrievedTx?.getTxHash()).toEqual(tx1.getTxHash());
+        await expect(pool.getTxStatus(tx1.getTxHash())).resolves.toEqual('mined');
         await expect(pool.getMinedTxHashes()).resolves.toEqual([
             [
-                await tx1.getTxHash(),
+                tx1.getTxHash(),
                 1
             ]
         ]);
         await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            await tx2.getTxHash()
+            tx2.getTxHash()
         ]);
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Marks txs as pending after being mined', async ()=>{
+    it('marks txs as pending after being mined', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         await pool.addTxs([
@@ -62,35 +117,36 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2
         ]);
         await pool.markAsMined([
-            await tx1.getTxHash()
-        ], 1);
+            tx1.getTxHash()
+        ], minedBlockHeader);
         await pool.markMinedAsPending([
-            await tx1.getTxHash()
-        ]);
+            tx1.getTxHash()
+        ], BlockNumber(1));
         await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
         const pending = await pool.getPendingTxHashes();
         expect(pending).toHaveLength(2);
         expect(pending).toEqual(expect.arrayContaining([
-            await tx1.getTxHash(),
-            await tx2.getTxHash()
+            tx1.getTxHash(),
+            tx2.getTxHash()
         ]));
+        await expect(pool.getPendingTxCount()).resolves.toEqual(2);
     });
-    it('Only marks txs as pending if they are known', async ()=>{
+    it('only marks txs as pending if they are known', async ()=>{
         const tx1 = await mockTx(1);
         // simulate a situation where not all peers have all the txs
         const tx2 = await mockTx(2);
-        const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
+        const someTxHashThatThisPeerDidNotSee = tx2.getTxHash();
         await pool.addTxs([
             tx1
         ]);
         // this peer knows that tx2 was mined, but it does not have the tx object
         await pool.markAsMined([
-            await tx1.getTxHash(),
+            tx1.getTxHash(),
             someTxHashThatThisPeerDidNotSee
-        ], 1);
+        ], minedBlockHeader);
         expect(await pool.getMinedTxHashes()).toEqual(expect.arrayContaining([
             [
-                await tx1.getTxHash(),
+                tx1.getTxHash(),
                 1
             ],
             [
@@ -100,15 +156,16 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]));
         // reorg: both txs should now become available again
         await pool.markMinedAsPending([
-            await tx1.getTxHash(),
+            tx1.getTxHash(),
             someTxHashThatThisPeerDidNotSee
-        ]);
+        ], BlockNumber(1));
         await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
         await expect(pool.getPendingTxHashes()).resolves.toEqual([
-            await tx1.getTxHash()
+            tx1.getTxHash()
         ]); // tx2 is not in the pool
+        await expect(pool.getPendingTxCount()).resolves.toEqual(1);
     });
-    it('Returns all transactions in the pool', async ()=>{
+    it('returns all transactions in the pool', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         const tx3 = await mockTx(3);
@@ -119,13 +176,66 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]);
         const poolTxs = await pool.getAllTxs();
         expect(poolTxs).toHaveLength(3);
-        expect(poolTxs).toEqual(expect.arrayContaining([
+        const poolHashes = poolTxs.map((tx)=>tx.getTxHash());
+        expect(poolHashes).toEqual(expect.arrayContaining([
+            tx1.getTxHash(),
+            tx2.getTxHash(),
+            tx3.getTxHash()
+        ]));
+        await expect(pool.getPendingTxCount()).resolves.toEqual(3);
+    });
+    it('returns all txHashes in the pool', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        const tx3 = await mockTx(3);
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3
+        ]);
+        const poolTxHashes = await pool.getAllTxHashes();
+        const expectedHashes = [
             tx1,
             tx2,
             tx3
+        ].map((tx)=>tx.getTxHash());
+        expect(poolTxHashes).toHaveLength(3);
+        expect(poolTxHashes).toEqual(expect.arrayContaining(expectedHashes));
+        await expect(pool.getPendingTxCount()).resolves.toEqual(3);
+    });
+    it('returns txs by their hash', async ()=>{
+        const tx1 = await mockTx(1);
+        const tx2 = await mockTx(2);
+        const tx3 = await mockTx(3);
+        await pool.addTxs([
+            tx1,
+            tx2,
+            tx3
+        ]);
+        const requestedTxs = await pool.getTxsByHash([
+            tx1.getTxHash(),
+            tx3.getTxHash()
+        ]);
+        expect(requestedTxs).toHaveLength(2);
+        const requestedHashes = requestedTxs.map((tx)=>tx.getTxHash());
+        expect(requestedHashes).toEqual(expect.arrayContaining([
+            tx1.getTxHash(),
+            tx3.getTxHash()
         ]));
     });
-    it('Returns all txHashes in the pool', async ()=>{
+    it('returns a large number of transactions by their hash', async ()=>{
+        const numTxs = 1_000;
+        const txs = await Promise.all(Array.from({
+            length: numTxs
+        }, (_, i)=>mockTx(i)));
+        const hashes = txs.map((tx)=>tx.getTxHash());
+        await pool.addTxs(txs);
+        const requestedTxs = await pool.getTxsByHash(hashes);
+        expect(requestedTxs).toHaveLength(numTxs);
+        const requestedHashes = requestedTxs.map((tx)=>tx.getTxHash());
+        expect(requestedHashes).toEqual(expect.arrayContaining(hashes));
+    });
+    it('returns whether or not txs exist', async ()=>{
         const tx1 = await mockTx(1);
         const tx2 = await mockTx(2);
         const tx3 = await mockTx(3);
@@ -134,15 +244,25 @@ import { mockTx } from '@aztec/stdlib/testing';
             tx2,
             tx3
         ]);
-        const poolTxHashes = await pool.getAllTxHashes();
-        expect(poolTxHashes).toHaveLength(3);
-        expect(poolTxHashes).toEqual(expect.arrayContaining([
-            await tx1.getTxHash(),
-            await tx2.getTxHash(),
-            await tx3.getTxHash()
+        const tx4 = await mockTx(4);
+        const tx5 = await mockTx(5);
+        const availability = await pool.hasTxs([
+            tx1.getTxHash(),
+            tx2.getTxHash(),
+            tx3.getTxHash(),
+            tx4.getTxHash(),
+            tx5.getTxHash()
+        ]);
+        expect(availability).toHaveLength(5);
+        expect(availability).toEqual(expect.arrayContaining([
+            true,
+            true,
+            true,
+            false,
+            false
         ]));
     });
-    it('Returns pending tx hashes sorted by priority', async ()=>{
+    it('returns pending tx hashes sorted by priority', async ()=>{
         const withPriorityFee = (tx, fee)=>{
             unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
             return tx;
@@ -159,11 +279,122 @@ import { mockTx } from '@aztec/stdlib/testing';
         ]);
         const poolTxHashes = await pool.getPendingTxHashes();
         expect(poolTxHashes).toHaveLength(4);
-        expect(poolTxHashes).toEqual(await Promise.all([
+        expect(poolTxHashes).toEqual([
             tx4,
             tx1,
             tx3,
             tx2
-        ].map((tx)=>tx.getTxHash())));
+        ].map((tx)=>tx.getTxHash()));
+    });
+    describe('soft-delete', ()=>{
+        it('soft-deletes mined txs and keeps them in storage', async ()=>{
+            const txs = await Promise.all([
+                mockTx(1),
+                mockTx(2),
+                mockTx(3)
+            ]);
+            await pool.addTxs(txs);
+            // Mark first tx as mined
+            await pool.markAsMined([
+                txs[0].getTxHash()
+            ], minedBlockHeader);
+            // Verify initial state
+            await expect(pool.getPendingTxCount()).resolves.toBe(2);
+            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeDefined();
+            // Delete mined tx - should be soft-deleted
+            await pool.deleteTxs([
+                txs[0].getTxHash()
+            ]);
+            // Delete pending tx - should be permanently deleted
+            await pool.deleteTxs([
+                txs[1].getTxHash()
+            ]);
+            // Verify mined tx still exists in storage but has 'deleted' status
+            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+            await expect(pool.getTxStatus(txs[0].getTxHash())).resolves.toEqual('deleted');
+            // Verify pending tx is permanently deleted
+            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+            await expect(pool.getTxStatus(txs[1].getTxHash())).resolves.toBeUndefined();
+            // Verify remaining pending count
+            await expect(pool.getPendingTxCount()).resolves.toBe(1);
+            // Verify pending hashes don't include deleted txs
+            const pendingHashes = await pool.getPendingTxHashes();
+            expect(pendingHashes).toHaveLength(1);
+            expect(pendingHashes.map((h)=>h.toString())).toContain(txs[2].getTxHash().toString());
+        });
+        it('cleans up old deleted mined transactions', async ()=>{
+            const txs = await Promise.all([
+                mockTx(1),
+                mockTx(2),
+                mockTx(3)
+            ]);
+            await pool.addTxs(txs);
+            // Mark first two as mined in block 1
+            await pool.markAsMined([
+                txs[0].getTxHash(),
+                txs[1].getTxHash()
+            ], minedBlockHeader);
+            // Soft-delete mined transactions
+            await pool.deleteTxs([
+                txs[0].getTxHash(),
+                txs[1].getTxHash()
+            ]);
+            // Clean up deleted mined txs from block 1 and earlier
+            const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
+            // Verify old transactions are permanently deleted
+            expect(deletedCount).toBe(2);
+            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeUndefined();
+            await expect(pool.getTxByHash(txs[1].getTxHash())).resolves.toBeUndefined();
+            await expect(pool.getTxByHash(txs[2].getTxHash())).resolves.toBeDefined();
+        });
+        it('does not clean up recent deleted mined transactions', async ()=>{
+            const txs = await Promise.all([
+                mockTx(1),
+                mockTx(2)
+            ]);
+            await pool.addTxs(txs);
+            // Mark as mined in block 2
+            const laterBlockHeader = BlockHeader.empty({
+                globalVariables: GlobalVariables.empty({
+                    blockNumber: BlockNumber(2),
+                    timestamp: 0n
+                })
+            });
+            await pool.markAsMined([
+                txs[0].getTxHash()
+            ], laterBlockHeader);
+            // Soft-delete a mined transaction
+            await pool.deleteTxs([
+                txs[0].getTxHash()
+            ]);
+            // Try to clean up with block 1 (before the mined block)
+            const deletedCount = await pool.cleanupDeletedMinedTxs(BlockNumber(1));
+            // Verify no transactions were cleaned up
+            expect(deletedCount).toBe(0);
+            await expect(pool.getTxByHash(txs[0].getTxHash())).resolves.toBeDefined();
+        });
+        it('restores deleted mined tx when it is mined again', async ()=>{
+            const tx = await mockTx(1);
+            await pool.addTxs([
+                tx
+            ]);
+            // Mark as mined
+            await pool.markAsMined([
+                tx.getTxHash()
+            ], minedBlockHeader);
+            // Soft-delete it
+            await pool.deleteTxs([
+                tx.getTxHash()
+            ]);
+            await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('deleted');
+            // Mark as mined again (e.g., after a reorg)
+            await pool.markAsMined([
+                tx.getTxHash()
+            ], minedBlockHeader);
+            // Should be back to mined status
+            await expect(pool.getTxStatus(tx.getTxHash())).resolves.toEqual('mined');
+            await expect(pool.getTxByHash(tx.getTxHash())).resolves.toBeDefined();
+        });
     });
 }

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts

@@ -1,8 +1,10 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockAttestation, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export declare class AttestationValidator implements P2PValidator<BlockAttestation> {
-    private epochCache;
+import { type Logger } from '@aztec/foundation/log';
+import { type CheckpointAttestation, type P2PValidator, type ValidationResult } from '@aztec/stdlib/p2p';
+export declare class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
+    protected epochCache: EpochCacheInterface;
+    protected logger: Logger;
     constructor(epochCache: EpochCacheInterface);
-    validate(message: BlockAttestation): Promise<PeerErrorSeverity | undefined>;
+    validate(message: CheckpointAttestation): Promise<ValidationResult>;
 }
-//# sourceMappingURL=attestation_validator.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvYXR0ZXN0YXRpb25fdmFsaWRhdG9yL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRTlELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQ0wsS0FBSyxxQkFBcUIsRUFDMUIsS0FBSyxZQUFZLEVBRWpCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sbUJBQW1CLENBQUM7QUFJM0IscUJBQWEsOEJBQStCLFlBQVcsWUFBWSxDQUFDLHFCQUFxQixDQUFDO0lBQ3hGLFNBQVMsQ0FBQyxVQUFVLEVBQUUsbUJBQW1CLENBQUM7SUFDMUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFFekIsWUFBWSxVQUFVLEVBQUUsbUJBQW1CLEVBRzFDO0lBRUssUUFBUSxDQUFDLE9BQU8sRUFBRSxxQkFBcUIsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0E2RHhFO0NBQ0YifQ==

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEhG,qBAAa,oBAAqB,YAAW,YAAY,CAAC,gBAAgB,CAAC;IACzE,OAAO,CAAC,UAAU,CAAsB;gBAE5B,UAAU,EAAE,mBAAmB;IAIrC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAelF"}
+{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAI3B,qBAAa,8BAA+B,YAAW,YAAY,CAAC,qBAAqB,CAAC;IACxF,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IAEzB,YAAY,UAAU,EAAE,mBAAmB,EAG1C;IAEK,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6DxE;CACF"}

package/dest/msg_validators/attestation_validator/attestation_validator.js

@@ -1,19 +1,88 @@
+import { NoCommitteeError } from '@aztec/ethereum/contracts';
+import { createLogger } from '@aztec/foundation/log';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export class AttestationValidator {
+import { isWithinClockTolerance } from '../clock_tolerance.js';
+export class CheckpointAttestationValidator {
     epochCache;
+    logger;
     constructor(epochCache){
         this.epochCache = epochCache;
+        this.logger = createLogger('p2p:checkpoint-attestation-validator');
     }
     async validate(message) {
-        const { currentSlot, nextSlot } = await this.epochCache.getProposerInCurrentOrNextSlot();
-        const slotNumberBigInt = message.payload.header.globalVariables.slotNumber.toBigInt();
-        if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-            return PeerErrorSeverity.HighToleranceError;
+        const slotNumber = message.payload.header.slotNumber;
+        try {
+            const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
+            if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
+                // Check if message is for previous slot and within clock tolerance
+                if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
+                    this.logger.warn(`Checkpoint attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
+                    return {
+                        result: 'reject',
+                        severity: PeerErrorSeverity.HighToleranceError
+                    };
+                }
+                this.logger.debug(`Ignoring checkpoint attestation for previous slot ${slotNumber} within clock tolerance`);
+                return {
+                    result: 'ignore'
+                };
+            }
+            // Verify the signature is valid
+            const attester = message.getSender();
+            if (attester === undefined) {
+                this.logger.warn(`Invalid signature in checkpoint attestation for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.LowToleranceError
+                };
+            }
+            // Verify the attester is in the committee for this slot
+            if (!await this.epochCache.isInCommittee(slotNumber, attester)) {
+                this.logger.warn(`Attester ${attester.toString()} is not in committee for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.HighToleranceError
+                };
+            }
+            // Verify the proposer signature matches the expected proposer for the attestation's slot
+            // We look up the proposer for the specific slot rather than using currentSlot/nextSlot
+            // since timing differences could cause mismatches
+            const proposer = message.getProposer();
+            const expectedProposer = await this.epochCache.getProposerAttesterAddressInSlot(slotNumber);
+            if (!expectedProposer) {
+                this.logger.warn(`No proposer defined for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.HighToleranceError
+                };
+            }
+            if (!proposer) {
+                this.logger.warn(`Invalid proposer signature in checkpoint attestation for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.LowToleranceError
+                };
+            }
+            if (!proposer.equals(expectedProposer)) {
+                this.logger.warn(`Proposer signature mismatch in checkpoint attestation. ` + `Expected ${expectedProposer?.toString() ?? 'none'} but got ${proposer.toString()} for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.HighToleranceError
+                };
+            }
+            return {
+                result: 'accept'
+            };
+        } catch (e) {
+            // People shouldn't be sending us attestations if the committee doesn't exist
+            if (e instanceof NoCommitteeError) {
+                this.logger.warn(`No committee exists for checkpoint attestation for slot ${slotNumber}`);
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.LowToleranceError
+                };
+            }
+            throw e;
         }
-        const attester = await message.getSender();
-        if (!await this.epochCache.isInCommittee(attester)) {
-            return PeerErrorSeverity.HighToleranceError;
-        }
-        return undefined;
     }
 }

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts

@@ -0,0 +1,20 @@
+import type { EpochCacheInterface } from '@aztec/epoch-cache';
+import { type CheckpointAttestation, type ValidationResult } from '@aztec/stdlib/p2p';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import type { AttestationPool } from '../../mem_pools/attestation_pool/attestation_pool.js';
+import { CheckpointAttestationValidator } from './attestation_validator.js';
+/**
+ * FishermanAttestationValidator extends the base AttestationValidator to add
+ * additional validation for fisherman nodes: verifying that attestations sign
+ * the same payload as the original proposal.
+ * Invalid attestations are rejected (not propagated), but peer penalization is
+ * handled by LibP2PService based on the fishermanMode config to ensure a better
+ * view of the network.
+ */
+export declare class FishermanAttestationValidator extends CheckpointAttestationValidator {
+    private attestationPool;
+    private invalidAttestationCounter;
+    constructor(epochCache: EpochCacheInterface, attestationPool: AttestationPool, telemetryClient: TelemetryClient);
+    validate(message: CheckpointAttestation): Promise<ValidationResult>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlzaGVybWFuX2F0dGVzdGF0aW9uX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci9maXNoZXJtYW5fYXR0ZXN0YXRpb25fdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUFFLEtBQUsscUJBQXFCLEVBQXFCLEtBQUssZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN6RyxPQUFPLEVBQXVCLEtBQUssZUFBZSxFQUFrQyxNQUFNLHlCQUF5QixDQUFDO0FBRXBILE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNEQUFzRCxDQUFDO0FBQzVGLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCxxQkFBYSw2QkFBOEIsU0FBUSw4QkFBOEI7SUFLN0UsT0FBTyxDQUFDLGVBQWU7SUFKekIsT0FBTyxDQUFDLHlCQUF5QixDQUFDO0lBRWxDLFlBQ0UsVUFBVSxFQUFFLG1CQUFtQixFQUN2QixlQUFlLEVBQUUsZUFBZSxFQUN4QyxlQUFlLEVBQUUsZUFBZSxFQWFqQztJQUVjLFFBQVEsQ0FBQyxPQUFPLEVBQUUscUJBQXFCLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBd0RqRjtDQUNGIn0=

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fisherman_attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/fisherman_attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,qBAAqB,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACzG,OAAO,EAAuB,KAAK,eAAe,EAAkC,MAAM,yBAAyB,CAAC;AAEpH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sDAAsD,CAAC;AAC5F,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,6BAA8B,SAAQ,8BAA8B;IAK7E,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,yBAAyB,CAAC;IAElC,YACE,UAAU,EAAE,mBAAmB,EACvB,eAAe,EAAE,eAAe,EACxC,eAAe,EAAE,eAAe,EAajC;IAEc,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwDjF;CACF"}

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.js

@@ -0,0 +1,76 @@
+import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+import { CheckpointAttestationValidator } from './attestation_validator.js';
+/**
+ * FishermanAttestationValidator extends the base AttestationValidator to add
+ * additional validation for fisherman nodes: verifying that attestations sign
+ * the same payload as the original proposal.
+ * Invalid attestations are rejected (not propagated), but peer penalization is
+ * handled by LibP2PService based on the fishermanMode config to ensure a better
+ * view of the network.
+ */ export class FishermanAttestationValidator extends CheckpointAttestationValidator {
+    attestationPool;
+    invalidAttestationCounter;
+    constructor(epochCache, attestationPool, telemetryClient){
+        super(epochCache), this.attestationPool = attestationPool;
+        this.logger = this.logger.createChild('[FISHERMAN]');
+        const meter = telemetryClient.getMeter('FishermanAttestationValidator');
+        this.invalidAttestationCounter = createUpDownCounterWithDefault(meter, Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT, {
+            [Attributes.ERROR_TYPE]: [
+                'base_validation_failed',
+                'payload_mismatch'
+            ]
+        });
+    }
+    async validate(message) {
+        // First run the standard validation
+        const baseValidationResult = await super.validate(message);
+        if (baseValidationResult.result !== 'accept') {
+            // Track base validation failures (invalid signature, wrong committee, etc.)
+            this.invalidAttestationCounter.add(1, {
+                [Attributes.ERROR_TYPE]: 'base_validation_failed'
+            });
+            return baseValidationResult;
+        }
+        // fisherman validation: verify attestation payload matches proposal payload
+        const slotNumberBigInt = message.payload.header.slotNumber;
+        const attester = message.getSender();
+        const proposer = message.getProposer();
+        if (!attester || !proposer) {
+            return {
+                result: 'accept'
+            };
+        }
+        const proposalId = message.archive.toString();
+        const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
+        if (proposal) {
+            // Compare the attestation payload with the proposal payload
+            if (!message.payload.equals(proposal)) {
+                this.logger.error(`Attestation payload mismatch for slot ${slotNumberBigInt}! ` + `Attester ${attester.toString()} signed different data than the proposal.`, {
+                    slot: slotNumberBigInt.toString(),
+                    attester: attester.toString(),
+                    proposer: proposer.toString(),
+                    proposalArchive: proposal.archive.toString(),
+                    attestationArchive: message.archive.toString(),
+                    proposalHeader: proposal.checkpointHeader.hash().toString(),
+                    attestationHeader: message.payload.header.hash().toString()
+                });
+                // Track invalid attestation metric
+                this.invalidAttestationCounter.add(1, {
+                    [Attributes.ERROR_TYPE]: 'payload_mismatch'
+                });
+                // Return error to reject the message, but LibP2PService won't penalize in fisherman mode
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.LowToleranceError
+                };
+            }
+        } else {
+            // We might receive attestations before proposals in some cases
+            this.logger.debug(`Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`);
+        }
+        return {
+            result: 'accept'
+        };
+    }
+}

package/dest/msg_validators/attestation_validator/index.d.ts

@@ -1,2 +1,3 @@
 export * from './attestation_validator.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './fisherman_attestation_validator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tc2dfdmFsaWRhdG9ycy9hdHRlc3RhdGlvbl92YWxpZGF0b3IvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHNDQUFzQyxDQUFDIn0=