@aztec/p2p 2.1.0-rc.9 → 2.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/p2p",
-  "version": "2.1.0-rc.9",
+  "version": "2.1.2",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -67,19 +67,17 @@
     ]
   },
   "dependencies": {
-    "@aztec/constants": "2.1.0-rc.9",
-    "@aztec/epoch-cache": "2.1.0-rc.9",
-    "@aztec/ethereum": "2.1.0-rc.9",
-    "@aztec/foundation": "2.1.0-rc.9",
-    "@aztec/kv-store": "2.1.0-rc.9",
-    "@aztec/noir-contracts.js": "2.1.0-rc.9",
-    "@aztec/noir-protocol-circuits-types": "2.1.0-rc.9",
-    "@aztec/protocol-contracts": "2.1.0-rc.9",
-    "@aztec/simulator": "2.1.0-rc.9",
-    "@aztec/stdlib": "2.1.0-rc.9",
-    "@aztec/telemetry-client": "2.1.0-rc.9",
-    "@chainsafe/discv5": "9.0.0",
-    "@chainsafe/enr": "3.0.0",
+    "@aztec/constants": "2.1.2",
+    "@aztec/epoch-cache": "2.1.2",
+    "@aztec/ethereum": "2.1.2",
+    "@aztec/foundation": "2.1.2",
+    "@aztec/kv-store": "2.1.2",
+    "@aztec/noir-contracts.js": "2.1.2",
+    "@aztec/noir-protocol-circuits-types": "2.1.2",
+    "@aztec/protocol-contracts": "2.1.2",
+    "@aztec/simulator": "2.1.2",
+    "@aztec/stdlib": "2.1.2",
+    "@aztec/telemetry-client": "2.1.2",
     "@chainsafe/libp2p-gossipsub": "13.0.0",
     "@chainsafe/libp2p-noise": "^15.0.0",
     "@chainsafe/libp2p-yamux": "^6.0.2",
@@ -94,6 +92,8 @@
     "@libp2p/prometheus-metrics": "^4.2.4",
     "@libp2p/tcp": "9.0.24",
     "@multiformats/multiaddr": "12.1.14",
+    "@nethermindeth/discv5": "9.0.0-backport-306-v4",
+    "@nethermindeth/enr": "3.0.0-backport-306-v4",
     "interface-datastore": "^8.2.11",
     "interface-store": "^5.1.8",
     "libp2p": "1.5.0",
@@ -104,8 +104,8 @@
     "xxhash-wasm": "^1.1.0"
   },
   "devDependencies": {
-    "@aztec/archiver": "2.1.0-rc.9",
-    "@aztec/world-state": "2.1.0-rc.9",
+    "@aztec/archiver": "2.1.2",
+    "@aztec/world-state": "2.1.2",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/node": "^22.15.17",
@@ -117,7 +117,7 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.3.3",
     "uint8arrays": "^5.0.3",
-    "viem": "2.23.7"
+    "viem": "npm:@spalladino/viem@2.38.2-eip7594.0"
   },
   "files": [
     "dest",

package/src/bootstrap/bootstrap.ts

@@ -3,14 +3,14 @@ import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { P2PBootstrapApi } from '@aztec/stdlib/interfaces/server';
 import { OtelMetricsAdapter, type TelemetryClient } from '@aztec/telemetry-client';
 
-import { Discv5, type Discv5EventEmitter } from '@chainsafe/discv5';
-import { ENR, type SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { Discv5, type Discv5EventEmitter } from '@nethermindeth/discv5';
+import { ENR, type SignableENR } from '@nethermindeth/enr';
 
 import type { BootnodeConfig } from '../config.js';
 import { createBootnodeENRandPeerId } from '../enr/generate-enr.js';
-import { convertToMultiaddr, getPeerIdPrivateKey } from '../util.js';
+import { convertToMultiaddr, getPeerIdPrivateKey, getPublicIp } from '../util.js';
 
 /**
  * Encapsulates a 'Bootstrap' node, used for the purpose of assisting new joiners in acquiring peers.
@@ -31,7 +31,18 @@ export class BootstrapNode implements P2PBootstrapApi {
    * @returns An empty promise.
    */
   public async start(config: BootnodeConfig) {
-    const { p2pIp, p2pPort, listenAddress, p2pBroadcastPort } = config;
+    const { p2pPort, listenAddress, p2pBroadcastPort, queryForIp } = config;
+    let p2pIp = config.p2pIp;
+    this.logger.info(`Starting bootstrap node with config: ${JSON.stringify(config)}`);
+    if (!p2pIp) {
+      if (queryForIp) {
+        this.logger.info('Querying for public IP address...');
+        const publicIp = await getPublicIp();
+        p2pIp = publicIp;
+        this.logger.info(`Found public IP address: ${publicIp}`);
+      }
+    }
+
     if (!p2pIp) {
       throw new Error('You need to provide a P2P IP address.');
     }

package/src/client/factory.ts

@@ -14,7 +14,7 @@ import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-clien
 import { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { InMemoryAttestationPool } from '../mem_pools/attestation_pool/memory_attestation_pool.js';
+import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
 import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
 import { DummyP2PService } from '../services/dummy_service.js';
@@ -35,6 +35,7 @@ export type P2PClientDeps<T extends P2PClientType> = {
 export const P2P_STORE_NAME = 'p2p';
 export const P2P_ARCHIVE_STORE_NAME = 'p2p-archive';
 export const P2P_PEER_STORE_NAME = 'p2p-peers';
+export const P2P_ATTESTATION_STORE_NAME = 'p2p-attestation';
 
 export async function createP2PClient<T extends P2PClientType>(
   clientType: T,
@@ -50,7 +51,7 @@ export async function createP2PClient<T extends P2PClientType>(
 ) {
   const config = await configureP2PClientAddresses({
     ...inputConfig,
-    dataStoreMapSizeKB: inputConfig.p2pStoreMapSizeKb ?? inputConfig.dataStoreMapSizeKB,
+    dataStoreMapSizeKb: inputConfig.p2pStoreMapSizeKb ?? inputConfig.dataStoreMapSizeKb,
   });
 
   const logger = deps.logger ?? createLogger('p2p');
@@ -64,6 +65,12 @@ export async function createP2PClient<T extends P2PClientType>(
   const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, createLogger('p2p:lmdb-v2')));
   const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, createLogger('p2p-archive:lmdb-v2'));
   const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, createLogger('p2p-peer:lmdb-v2'));
+  const attestationStore = await createStore(
+    P2P_ATTESTATION_STORE_NAME,
+    1,
+    config,
+    createLogger('p2p-attestation:lmdb-v2'),
+  );
   const l1Constants = await archiver.getL1Constants();
 
   const mempools: MemPools<T> = {
@@ -75,7 +82,7 @@ export async function createP2PClient<T extends P2PClientType>(
       }),
     attestationPool:
       clientType === P2PClientType.Full
-        ? ((deps.attestationPool ?? new InMemoryAttestationPool(telemetry)) as T extends P2PClientType.Full
+        ? ((deps.attestationPool ?? new KvAttestationPool(attestationStore, telemetry)) as T extends P2PClientType.Full
             ? AttestationPool
             : undefined)
         : undefined,

package/src/client/interface.ts

@@ -3,8 +3,8 @@ import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
 import type { BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
 import type { Tx, TxHash } from '@aztec/stdlib/tx';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 
 import type { P2PConfig } from '../config.js';
 import type { AuthRequest, StatusMessage } from '../services/index.js';

package/src/client/p2p_client.ts

@@ -26,8 +26,8 @@ import {
   trackSpan,
 } from '@aztec/telemetry-client';
 
-import type { ENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
+import type { ENR } from '@nethermindeth/enr';
 
 import { type P2PConfig, getP2PDefaultConfig } from '../config.js';
 import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
@@ -123,7 +123,13 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
       const constants = this.txCollection.getConstants();
       const nextSlotTimestampSeconds = Number(getTimestampForSlot(block.slotNumber.toBigInt() + 1n, constants));
       const deadline = new Date(nextSlotTimestampSeconds * 1000);
-      await this.txProvider.getTxsForBlockProposal(block, { pinnedPeer: sender, deadline });
+      const parentBlock = await this.l2BlockSource.getBlockHeaderByArchive(block.payload.header.lastArchiveRoot);
+      if (!parentBlock) {
+        this.log.debug(`Cannot collect txs for proposal as parent block not found`);
+        return;
+      }
+      const blockNumber = parentBlock.getBlockNumber() + 1;
+      await this.txProvider.getTxsForBlockProposal(block, blockNumber, { pinnedPeer: sender, deadline });
       return undefined;
     });
 
@@ -365,7 +371,6 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
   }
 
   @trackSpan('p2pClient.broadcastProposal', async proposal => ({
-    [Attributes.BLOCK_NUMBER]: proposal.blockNumber,
     [Attributes.SLOT_NUMBER]: proposal.slotNumber.toNumber(),
     [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
     [Attributes.P2P_ID]: (await proposal.p2pMessageIdentifier()).toString(),
@@ -387,6 +392,10 @@ export class P2PClient<T extends P2PClientType = P2PClientType.Full>
     return this.attestationPool?.addAttestations(attestations) ?? Promise.resolve();
   }
 
+  public deleteAttestation(attestation: BlockAttestation): Promise<void> {
+    return this.attestationPool?.deleteAttestations([attestation]) ?? Promise.resolve();
+  }
+
   // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
   // ^ This pattern is not my favorite (md)
   public registerBlockProposalHandler(handler: P2PBlockReceivedCallback): void {

package/src/config.ts

@@ -127,7 +127,7 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionCo
   /** A list of preferred peers. */
   preferredPeers: string[];
 
-  /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB. */
+  /** The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb. */
   p2pStoreMapSizeKb?: number;
 
   /** Which calls are allowed in the public setup phase of a tx. */
@@ -360,7 +360,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   p2pStoreMapSizeKb: {
     env: 'P2P_STORE_MAP_SIZE_KB',
     parseEnv: (val: string | undefined) => (val ? +val : undefined),
-    description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKB.',
+    description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.',
   },
   txPublicSetupAllowList: {
     env: 'TX_PUBLIC_SETUP_ALLOWLIST',
@@ -449,9 +449,10 @@ export type BootnodeConfig = Pick<
   | 'peerIdPrivateKeyPath'
   | 'bootstrapNodes'
   | 'listenAddress'
+  | 'queryForIp'
 > &
   Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
-  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'> &
   Pick<ChainConfig, 'l1ChainId'>;
 
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
@@ -462,9 +463,10 @@ const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
   'peerIdPrivateKey',
   'peerIdPrivateKeyPath',
   'dataDirectory',
-  'dataStoreMapSizeKB',
+  'dataStoreMapSizeKb',
   'bootstrapNodes',
   'l1ChainId',
+  'queryForIp',
 ];
 
 export const bootnodeConfigMappings = pickConfigMappings(

package/src/enr/generate-enr.ts

@@ -2,9 +2,9 @@ import type { LogFn } from '@aztec/foundation/log';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
 import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
-import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
 import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { ENR, SignableENR } from '@nethermindeth/enr';
 
 import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from '../types/index.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';

package/src/mem_pools/attestation_pool/attestation_pool.ts

@@ -21,6 +21,15 @@ export interface AttestationPool {
    */
   getBlockProposal(id: string): Promise<BlockProposal | undefined>;
 
+  /**
+   * Check if a block proposal exists in the pool
+   *
+   * @param idOrProposal - The ID of the block proposal or the block proposal itself to check. The ID is proposal.payload.archive
+   *
+   * @return True if the block proposal exists, false otherwise.
+   */
+  hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean>;
+
   /**
    * AddAttestations
    *
@@ -84,6 +93,14 @@ export interface AttestationPool {
    */
   getAttestationsForSlotAndProposal(slot: bigint, proposalId: string): Promise<BlockAttestation[]>;
 
+  /**
+   * Check if a specific attestation exists in the pool
+   *
+   * @param attestation - The attestation to check
+   * @return True if the attestation exists, false otherwise
+   */
+  hasAttestation(attestation: BlockAttestation): Promise<boolean>;
+
   /** Returns whether the pool is empty. */
   isEmpty(): Promise<boolean>;
 }

package/src/mem_pools/attestation_pool/attestation_pool_test_suite.ts

@@ -41,7 +41,6 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
   };
 
   const mockBlockProposal = (signer: Secp256k1Signer, slotNumber: number, archive: Fr = Fr.random()): BlockProposal => {
-    const blockNumber = 1;
     const header = makeHeader(1, 2, slotNumber);
     const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
 
@@ -50,7 +49,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
     const txHashes = [TxHash.random(), TxHash.random()]; // Mock tx hashes
 
-    return new BlockProposalClass(blockNumber, payload, signature, txHashes);
+    return new BlockProposalClass(payload, signature, txHashes);
   };
 
   // We compare buffers as the objects can have cached values attached to them which are not serialised
@@ -73,6 +72,11 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(retrievedAttestations.length).toBe(attestations.length);
     compareAttestations(retrievedAttestations, attestations);
 
+    // Check hasAttestation for added attestations
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
     const retrievedAttestationsForSlot = await ap.getAttestationsForSlot(BigInt(slotNumber));
     expect(retrievedAttestationsForSlot.length).toBe(attestations.length);
     compareAttestations(retrievedAttestationsForSlot, attestations);
@@ -86,6 +90,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     );
     expect(retrievedAttestationsAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsAfterAdd, [...attestations, newAttestation]);
+    expect(await ap.hasAttestation(newAttestation)).toBe(true);
     const retrievedAttestationsForSlotAfterAdd = await ap.getAttestationsForSlot(BigInt(slotNumber));
     expect(retrievedAttestationsForSlotAfterAdd.length).toBe(attestations.length + 1);
     compareAttestations(retrievedAttestationsForSlotAfterAdd, [...attestations, newAttestation]);
@@ -98,6 +103,11 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       archive.toString(),
     );
     expect(retreivedAttestationsAfterDelete.length).toBe(0);
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
+    expect(await ap.hasAttestation(newAttestation)).toBe(false);
   });
 
   it('should handle duplicate proposals in a slot', async () => {
@@ -117,7 +127,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     const retreivedAttestations = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), archive.toString());
     expect(retreivedAttestations.length).toBe(1);
     expect(retreivedAttestations[0].toBuffer()).toEqual(attestations[0].toBuffer());
-    expect(retreivedAttestations[0].getSender().toString()).toEqual(signer.address.toString());
+    expect(retreivedAttestations[0].getSender()?.toString()).toEqual(signer.address.toString());
 
     // Try adding them on another operation and check they are still not duplicated
     await ap.addAttestations([attestations[0]]);
@@ -171,10 +181,20 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
     expect(retreivedAttestations.length).toBe(NUMBER_OF_SIGNERS_PER_TEST);
     compareAttestations(retreivedAttestations, attestations);
 
+    // Check hasAttestation before deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(true);
+    }
+
     await ap.deleteAttestations(attestations);
 
     const gottenAfterDelete = await ap.getAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
     expect(gottenAfterDelete.length).toBe(0);
+
+    // Check hasAttestation after deletion
+    for (const attestation of attestations) {
+      expect(await ap.hasAttestation(attestation)).toBe(false);
+    }
   });
 
   it('should blanket delete attestations per slot', async () => {
@@ -266,12 +286,19 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal!).toEqual(proposal);
+
+      // Check hasBlockProposal with both id and object
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
     });
 
     it('should return undefined for non-existent block proposal', async () => {
       const nonExistentId = Fr.random().toString();
       const retrievedProposal = await ap.getBlockProposal(nonExistentId);
       expect(retrievedProposal).toBeUndefined();
+
+      // Check hasBlockProposal returns false for non-existent proposal
+      expect(await ap.hasBlockProposal(nonExistentId)).toBe(false);
     });
 
     it('should update block proposal if added twice with same id', async () => {
@@ -291,7 +318,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       expect(retrievedProposal).toBeDefined();
       // Should have the second proposal
       expect(retrievedProposal!.toBuffer()).toEqual(proposal2.toBuffer());
-      expect(retrievedProposal!.getSender().toString()).toBe(signers[1].address.toString());
+      expect(retrievedProposal!.getSender()?.toString()).toBe(signers[1].address.toString());
     });
 
     it('should handle block proposals with different slots and same archive', async () => {
@@ -324,6 +351,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       // Delete attestations for slot and proposal
       await ap.deleteAttestationsForSlotAndProposal(BigInt(slotNumber), proposalId);
@@ -331,6 +359,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposalId)).toBe(false);
     });
 
     it('should delete block proposal when deleting attestations for slot', async () => {
@@ -345,6 +374,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Verify proposal exists
       let retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeDefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(true);
 
       // Delete attestations for slot
       await ap.deleteAttestationsForSlot(BigInt(slotNumber));
@@ -352,6 +382,7 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
       // Proposal should be deleted
       retrievedProposal = await ap.getBlockProposal(proposalId);
       expect(retrievedProposal).toBeUndefined();
+      expect(await ap.hasBlockProposal(proposal)).toBe(false);
     });
 
     it('should be able to fetch both block proposal and attestations', async () => {
@@ -373,8 +404,13 @@ export function describeAttestationPool(getAttestationPool: () => AttestationPoo
 
       expect(retrievedProposal).toBeDefined();
       expect(retrievedProposal).toEqual(proposal);
+      expect(await ap.hasBlockProposal(proposalId)).toBe(true);
 
       compareAttestations(retrievedAttestations, attestations);
+      // Check hasAttestation for all attestations
+      for (const attestation of attestations) {
+        expect(await ap.hasAttestation(attestation)).toBe(true);
+      }
     });
   });
 }

package/src/mem_pools/attestation_pool/kv_attestation_pool.ts

@@ -66,7 +66,19 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
-        const address = attestation.getSender().toString();
+        const sender = attestation.getSender();
+
+        // Skip attestations with invalid signatures
+        if (!sender) {
+          this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber.toBigInt()}`, {
+            signature: attestation.signature.toString(),
+            slotNumber,
+            proposalId,
+          });
+          continue;
+        }
+
+        const address = sender.toString();
 
         await this.attestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
 
@@ -176,7 +188,15 @@ export class KvAttestationPool implements AttestationPool {
       for (const attestation of attestations) {
         const slotNumber = attestation.payload.header.slotNumber;
         const proposalId = attestation.archive;
-        const address = attestation.getSender().toString();
+        const sender = attestation.getSender();
+
+        // Skip attestations with invalid signatures
+        if (!sender) {
+          this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber.toBigInt()}`);
+          continue;
+        }
+
+        const address = sender.toString();
         const key = this.getAttestationKey(slotNumber, proposalId, address);
 
         if (await this.attestations.hasAsync(key)) {
@@ -193,6 +213,22 @@ export class KvAttestationPool implements AttestationPool {
     });
   }
 
+  public async hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive;
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return false;
+    }
+
+    const address = sender.toString();
+    const key = this.getAttestationKey(slotNumber, proposalId, address);
+
+    return await this.attestations.hasAsync(key);
+  }
+
   public async getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     const buffer = await this.proposals.getAsync(id);
     try {
@@ -206,6 +242,11 @@ export class KvAttestationPool implements AttestationPool {
     return Promise.resolve(undefined);
   }
 
+  public async hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return await this.proposals.hasAsync(id);
+  }
+
   public async addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     await this.store.transactionAsync(async () => {
       await this.proposalsForSlot.set(blockProposal.slotNumber.toString(), blockProposal.archive.toString());

package/src/mem_pools/attestation_pool/memory_attestation_pool.ts

@@ -55,16 +55,26 @@ export class InMemoryAttestationPool implements AttestationPool {
       const slotNumber = attestation.payload.header.slotNumber;
 
       const proposalId = attestation.archive.toString();
-      const address = attestation.getSender();
+      const sender = attestation.getSender();
+
+      // Skip attestations with invalid signatures
+      if (!sender) {
+        this.log.warn(`Skipping attestation with invalid signature for slot ${slotNumber.toBigInt()}`, {
+          signature: attestation.signature.toString(),
+          slotNumber,
+          proposalId,
+        });
+        continue;
+      }
 
       const slotAttestationMap = getSlotOrDefault(this.attestations, slotNumber.toBigInt());
       const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
-      proposalAttestationMap.set(address.toString(), attestation);
+      proposalAttestationMap.set(sender.toString(), attestation);
 
-      this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${address}`, {
+      this.log.verbose(`Added attestation for slot ${slotNumber.toBigInt()} from ${sender}`, {
         signature: attestation.signature.toString(),
         slotNumber,
-        address,
+        address: sender,
         proposalId,
       });
     }
@@ -147,15 +157,45 @@ export class InMemoryAttestationPool implements AttestationPool {
         const proposalId = attestation.archive.toString();
         const proposalAttestationMap = getProposalOrDefault(slotAttestationMap, proposalId);
         if (proposalAttestationMap) {
-          const address = attestation.getSender();
-          proposalAttestationMap.delete(address.toString());
-          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${address}`);
+          const sender = attestation.getSender();
+
+          // Skip attestations with invalid signatures
+          if (!sender) {
+            this.log.warn(`Skipping deletion of attestation with invalid signature for slot ${slotNumber.toBigInt()}`);
+            continue;
+          }
+
+          proposalAttestationMap.delete(sender.toString());
+          this.log.debug(`Deleted attestation for slot ${slotNumber} from ${sender}`);
         }
       }
     }
     return Promise.resolve();
   }
 
+  public hasAttestation(attestation: BlockAttestation): Promise<boolean> {
+    const slotNumber = attestation.payload.header.slotNumber;
+    const proposalId = attestation.archive.toString();
+    const sender = attestation.getSender();
+
+    // Attestations with invalid signatures are never in the pool
+    if (!sender) {
+      return Promise.resolve(false);
+    }
+
+    const slotAttestationMap = this.attestations.get(slotNumber.toBigInt());
+    if (!slotAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    const proposalAttestationMap = slotAttestationMap.get(proposalId);
+    if (!proposalAttestationMap) {
+      return Promise.resolve(false);
+    }
+
+    return Promise.resolve(proposalAttestationMap.has(sender.toString()));
+  }
+
   public addBlockProposal(blockProposal: BlockProposal): Promise<void> {
     // We initialize slot-proposal mapping if it does not exist
     // This is important to ensure we can delete this proposal if there were not attestations for it
@@ -169,6 +209,11 @@ export class InMemoryAttestationPool implements AttestationPool {
   public getBlockProposal(id: string): Promise<BlockProposal | undefined> {
     return Promise.resolve(this.proposals.get(id));
   }
+
+  public hasBlockProposal(idOrProposal: string | BlockProposal): Promise<boolean> {
+    const id = typeof idOrProposal === 'string' ? idOrProposal : idOrProposal.payload.archive.toString();
+    return Promise.resolve(this.proposals.has(id));
+  }
 }
 
 /**

package/src/mem_pools/attestation_pool/mocks.ts

@@ -35,8 +35,11 @@ export const mockAttestation = (
   const header = makeHeader(1, 2, slot);
   const payload = new ConsensusPayload(header.toPropose(), archive, header.state);
 
-  const hash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
-  const signature = signer.sign(hash);
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSignature = signer.sign(attestationHash);
 
-  return new BlockAttestation(header.globalVariables.blockNumber, payload, signature);
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposerSignature = signer.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -273,6 +273,11 @@ export class AztecKVTxPool extends (EventEmitter as new () => TypedEventEmitter<
     return await Promise.all(txHashes.map(txHash => this.#txs.hasAsync(txHash.toString())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   /**
    * Checks if an archived tx exists and returns it.
    * @param txHash - The tx hash.

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -151,6 +151,11 @@ export class InMemoryTxPool extends (EventEmitter as new () => TypedEventEmitter
     return Promise.resolve(txHashes.map(txHash => this.txs.has(txHash.toBigInt())));
   }
 
+  async hasTx(txHash: TxHash): Promise<boolean> {
+    const result = await this.hasTxs([txHash]);
+    return result[0];
+  }
+
   public getArchivedTxByHash(): Promise<Tx | undefined> {
     return Promise.resolve(undefined);
   }

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -43,6 +43,13 @@ export interface TxPool extends TypedEventEmitter<TxPoolEvents> {
    */
   hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
 
+  /**
+   * Checks if a transaction exists in the pool
+   * @param txHash - The hash of the transaction to check for
+   * @returns True if the transaction exists, false otherwise
+   */
+  hasTx(txHash: TxHash): Promise<boolean>;
+
   /**
    * Checks if an archived transaction exists in the pool and returns it.
    * @param txHash - The hash of the transaction, used as an ID.