@aztec/p2p 0.0.1-commit.f295ac2 → 0.0.1-commit.f8ca9b2f3

package/dest/mem_pools/attestation_pool/attestation_pool.js

@@ -1,6 +1,439 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { toArray } from '@aztec/foundation/iterable';
+import { createLogger } from '@aztec/foundation/log';
+import { BlockProposal, CheckpointAttestation, CheckpointProposal } from '@aztec/stdlib/p2p';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+export const MAX_CHECKPOINT_PROPOSALS_PER_SLOT = 5;
+export const MAX_BLOCK_PROPOSALS_PER_POSITION = 3;
+/** Maximum attestations a single signer can make per slot before being rejected. */ export const MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER = 3;
 /**
- * An Attestation Pool contains attestations collected by a validator
+ * Pool for storing attestations and proposals collected by a validator.
  *
- * Attestations that are observed via the p2p network are stored for requests
+ * Attestations and proposals observed via the p2p network are stored for requests
  * from the validator to produce a block, or to serve to other peers.
- */ export { };
+ */ export class AttestationPool {
+    store;
+    log;
+    metrics;
+    // Checkpoint attestations from attestation key (slot-proposalId-signer) to serialized CheckpointAttestation
+    // Keys are lexicographically sortable allowing range queries by slot or by (slot, proposalId)
+    checkpointAttestations;
+    // Checkpoint proposals from proposal archive to serialized CheckpointProposal
+    checkpointProposals;
+    // Checkpoint proposals indexed by slot for querying all proposals in a slot
+    // Key: slot number, Value: proposal archive strings
+    checkpointProposalsForSlot;
+    // Block proposals from proposal archive to serialized BlockProposal
+    blockProposals;
+    // Block proposals indexed by slot and index-within-checkpoint for duplicate detection
+    // Key: (slot << 10) | indexWithinCheckpoint, Value: archive string
+    blockProposalsForSlotAndIndex;
+    // Checkpoint attestations indexed by (slot, signer) for tracking attestations per (slot, signer) for duplicate detection
+    // Key: `${Fr(slot).toString()}-${signerAddress}` string (padded for lexicographic ordering), Value: `proposalId` strings
+    checkpointAttestationsPerSlotAndSigner;
+    constructor(store, telemetry = getTelemetryClient(), log = createLogger('aztec:attestation_pool')){
+        this.store = store;
+        this.log = log;
+        this.poolStats = async ()=>{
+            return {
+                itemCount: await this.checkpointAttestations.sizeAsync()
+            };
+        };
+        // Initialize block proposal storage
+        this.blockProposals = store.openMap('proposals');
+        this.blockProposalsForSlotAndIndex = store.openMultiMap('block_proposals_for_slot_and_index');
+        // Initialize checkpoint attestations storage
+        this.checkpointAttestations = store.openMap('checkpoint_attestations');
+        this.checkpointAttestationsPerSlotAndSigner = store.openMultiMap('checkpoint_attestations_per_slot_and_signer');
+        // Initialize checkpoint proposal storage
+        this.checkpointProposals = store.openMap('checkpoint_proposals');
+        this.checkpointProposalsForSlot = store.openMultiMap('checkpoint_proposals_for_slot');
+        this.metrics = new PoolInstrumentation(telemetry, PoolName.ATTESTATION_POOL, this.poolStats);
+    }
+    poolStats;
+    /** Returns whether the pool is empty. */ async isEmpty() {
+        for await (const _ of this.checkpointAttestations.entriesAsync()){
+            return false;
+        }
+        for await (const _ of this.blockProposals.entriesAsync()){
+            return false;
+        }
+        return true;
+    }
+    getProposalKey(slot, proposalId) {
+        const slotStr = typeof slot === 'string' ? slot : new Fr(slot).toString();
+        const proposalIdStr = typeof proposalId === 'string' ? proposalId : Buffer.isBuffer(proposalId) ? Fr.fromBuffer(proposalId).toString() : proposalId.toString();
+        return `${slotStr}-${proposalIdStr}`;
+    }
+    getAttestationKey(slot, proposalId, address) {
+        return `${this.getProposalKey(slot, proposalId)}-${address}`;
+    }
+    /** Returns range bounds for querying all attestations for a given slot. */ getAttestationKeyRangeForSlot(slot) {
+        const slotStr = new Fr(slot).toString();
+        return {
+            start: `${slotStr}-`,
+            end: `${slotStr}-Z`
+        }; // 'Z' sorts after any hex character
+    }
+    /** Returns range bounds for querying all attestations for a given (slot, proposalId). */ getAttestationKeyRangeForProposal(slot, proposalId) {
+        const proposalKey = this.getProposalKey(slot, proposalId);
+        return {
+            start: `${proposalKey}-`,
+            end: `${proposalKey}-Z`
+        };
+    }
+    /** Creates a key for the per-signer-per-slot attestation index. Uses padded slot for lexicographic ordering. */ getSlotSignerKey(slot, signerAddress) {
+        const slotStr = new Fr(slot).toString();
+        return `${slotStr}-${signerAddress}`;
+    }
+    /** Number of bits reserved for indexWithinCheckpoint in position keys. */ static INDEX_BITS = 10;
+    /** Maximum indexWithinCheckpoint value (2^10 - 1 = 1023). */ static MAX_INDEX = (1 << AttestationPool.INDEX_BITS) - 1;
+    /** Creates a position key for block proposals: (slot << 10) | indexWithinCheckpoint. */ getBlockPositionKey(slot, indexWithinCheckpoint) {
+        if (indexWithinCheckpoint > AttestationPool.MAX_INDEX) {
+            throw new Error(`Value for indexWithinCheckpoint ${indexWithinCheckpoint} exceeds maximum ${AttestationPool.MAX_INDEX}`);
+        }
+        return slot << AttestationPool.INDEX_BITS | indexWithinCheckpoint;
+    }
+    /**
+   * Attempts to add a block proposal to the pool.
+   *
+   * This method performs validation and addition in a single call:
+   * - Checks if the proposal already exists (returns alreadyExists: true if so)
+   * - Checks if the position has reached the proposal cap (returns added: false if so)
+   * - Adds the proposal if validation passes
+   *
+   * @param blockProposal - The block proposal to add
+   * @returns Result indicating whether the proposal was added and duplicate detection info
+   */ async tryAddBlockProposal(blockProposal) {
+        return await this.store.transactionAsync(async ()=>{
+            const proposalId = blockProposal.archive.toString();
+            // Check if already exists
+            const alreadyExists = await this.blockProposals.hasAsync(proposalId);
+            if (alreadyExists) {
+                const count = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    count
+                };
+            }
+            // Get current count for position and check cap, do not add if exceeded
+            const count = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+            if (count >= MAX_BLOCK_PROPOSALS_PER_POSITION) {
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    count
+                };
+            }
+            // Add the proposal
+            await this.addBlockProposal(blockProposal);
+            this.log.debug(`Added block proposal for slot ${blockProposal.slotNumber} and index ${blockProposal.indexWithinCheckpoint}`, {
+                proposalId,
+                slotNumber: blockProposal.slotNumber,
+                indexWithinCheckpoint: blockProposal.indexWithinCheckpoint
+            });
+            return {
+                added: true,
+                alreadyExists: false,
+                count: count + 1
+            };
+        });
+    }
+    /** Gets the count of block proposals for a given position (slot, indexWithinCheckpoint). */ getBlockProposalCountForPosition(slot, indexWithinCheckpoint) {
+        const positionKey = this.getBlockPositionKey(slot, indexWithinCheckpoint);
+        return this.blockProposalsForSlotAndIndex.getValueCountAsync(positionKey);
+    }
+    /** Internal method - must be called within a transaction. */ async addBlockProposal(blockProposal) {
+        const proposalId = blockProposal.archive.toString();
+        // Strip signedTxs before storing to avoid persisting full tx data
+        await this.blockProposals.set(proposalId, blockProposal.withoutSignedTxs().toBuffer());
+        // Index by slot and position for duplicate detection
+        const positionKey = this.getBlockPositionKey(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+        await this.blockProposalsForSlotAndIndex.set(positionKey, proposalId);
+    }
+    /**
+   * Get block proposal by its ID.
+   *
+   * @param id - The ID of the block proposal to retrieve. The ID is proposal.payload.archive
+   *
+   * @return The block proposal if it exists, otherwise undefined.
+   */ async getBlockProposal(id) {
+        const buffer = await this.blockProposals.getAsync(id);
+        try {
+            if (buffer && buffer.length > 0) {
+                return BlockProposal.fromBuffer(buffer);
+            }
+        } catch  {
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+   * Attempts to add a checkpoint proposal to the pool.
+   *
+   * This method performs validation and addition in a single call:
+   * - Checks if the proposal already exists (returns alreadyExists: true if so)
+   * - Checks if the slot has reached the proposal cap (returns added: false if so)
+   * - Adds the proposal if validation passes
+   *
+   * Note: This method only handles the CheckpointProposalCore. If the original
+   * CheckpointProposal contains a lastBlock, the caller should extract it via
+   * getBlockProposal() and add it separately via tryAddBlockProposal().
+   *
+   * @param proposal - The checkpoint proposal core to add
+   * @returns Result indicating whether the proposal was added and duplicate detection info
+   */ async tryAddCheckpointProposal(proposal) {
+        return await this.store.transactionAsync(async ()=>{
+            const proposalId = proposal.archive.toString();
+            // Check if already exists
+            const alreadyExists = await this.checkpointProposals.hasAsync(proposalId);
+            if (alreadyExists) {
+                const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    count
+                };
+            }
+            // Get current count for slot and check cap
+            const count = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+            if (count >= MAX_CHECKPOINT_PROPOSALS_PER_SLOT) {
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    count
+                };
+            }
+            // Add the proposal if cap not exceeded
+            await this.addCheckpointProposal(proposal);
+            this.log.debug(`Added checkpoint proposal for slot ${proposal.slotNumber}`, {
+                proposalId,
+                slotNumber: proposal.slotNumber
+            });
+            return {
+                added: true,
+                alreadyExists: false,
+                count: count + 1
+            };
+        });
+    }
+    /** Internal method - must be called within a transaction. */ async addCheckpointProposal(proposal) {
+        const slotKey = proposal.slotNumber;
+        const proposalId = proposal.archive.toString();
+        await this.checkpointProposalsForSlot.set(slotKey, proposalId);
+        await this.checkpointProposals.set(proposalId, proposal.toBuffer());
+    }
+    /**
+   * Get checkpoint proposal by its ID.
+   *
+   * Returns a CheckpointProposalCore (without lastBlock info) since the lastBlock
+   * is extracted and stored separately as a BlockProposal when added.
+   *
+   * @param id - The ID of the checkpoint proposal to retrieve (proposal.archive)
+   * @return The checkpoint proposal core if it exists, otherwise undefined.
+   */ async getCheckpointProposal(id) {
+        const buffer = await this.checkpointProposals.getAsync(id);
+        try {
+            if (buffer && buffer.length > 0) {
+                return CheckpointProposal.fromBuffer(buffer);
+            }
+        } catch  {
+            return undefined;
+        }
+        return undefined;
+    }
+    /**
+   * Adds own checkpoint attestations to the pool.
+   * Skips validations on number of checkpoint attestations stored for the given slot.
+   */ async addOwnCheckpointAttestations(attestations) {
+        await this.store.transactionAsync(async ()=>{
+            for (const attestation of attestations){
+                const slotNumber = attestation.payload.header.slotNumber;
+                const proposalId = attestation.archive;
+                const sender = attestation.getSender();
+                // Skip attestations with invalid signatures
+                if (!sender) {
+                    this.log.warn(`Skipping own checkpoint attestation with invalid signature for slot ${slotNumber}`, {
+                        signature: attestation.signature.toString(),
+                        slotNumber,
+                        proposalId
+                    });
+                    continue;
+                }
+                const address = sender.toString();
+                await this.checkpointAttestations.set(this.getAttestationKey(slotNumber, proposalId, address), attestation.toBuffer());
+                this.log.debug(`Added own checkpoint attestation for slot ${slotNumber} from ${address}`, {
+                    signature: attestation.signature.toString(),
+                    slotNumber,
+                    address,
+                    proposalId
+                });
+            }
+        });
+    }
+    /**
+   * Get all checkpoint attestations for a given slot.
+   *
+   * @param slot - The slot to query
+   * @return CheckpointAttestations
+   */ async getCheckpointAttestationsForSlot(slot) {
+        const range = this.getAttestationKeyRangeForSlot(slot);
+        const attestations = [];
+        for await (const [_, buf] of this.checkpointAttestations.entriesAsync(range)){
+            attestations.push(CheckpointAttestation.fromBuffer(buf));
+        }
+        return attestations;
+    }
+    /**
+   * Get checkpoint attestations for slot and given proposal.
+   *
+   * @param slot - The slot to query
+   * @param proposalId - The proposal to query
+   * @return CheckpointAttestations
+   */ async getCheckpointAttestationsForSlotAndProposal(slot, proposalId) {
+        const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
+        const attestations = [];
+        for await (const [_, buf] of this.checkpointAttestations.entriesAsync(range)){
+            attestations.push(CheckpointAttestation.fromBuffer(buf));
+        }
+        return attestations;
+    }
+    /**
+   * Delete all pool data (attestations, proposals) older than the given slot.
+   *
+   * @param oldestSlot - The oldest slot to keep.
+   */ async deleteOlderThan(oldestSlot) {
+        let numberOfAttestations = 0;
+        let numberOfCheckpointProposals = 0;
+        let numberOfBlockProposals = 0;
+        await this.store.transactionAsync(async ()=>{
+            // Delete checkpoint attestations with slot < oldestSlot
+            // Attestation keys start with Fr(slot).toString(), so we use end bound of Fr(oldestSlot).toString()
+            const attestationEndKey = new Fr(oldestSlot).toString();
+            for await (const key of this.checkpointAttestations.keysAsync({
+                end: attestationEndKey
+            })){
+                await this.checkpointAttestations.delete(key);
+                numberOfAttestations++;
+            }
+            // Clean up per-signer-per-slot index. Keys are formatted as `${Fr(slot).toString()}-${signerAddress}`.
+            // Since Fr pads to fixed-width hex, Fr(oldestSlot) is lexicographically greater than any key with
+            // a smaller slot (even with the signer suffix), so using it as the exclusive end bound is correct.
+            const slotSignerEndKey = new Fr(oldestSlot).toString();
+            for await (const key of this.checkpointAttestationsPerSlotAndSigner.keysAsync({
+                end: slotSignerEndKey
+            })){
+                await this.checkpointAttestationsPerSlotAndSigner.delete(key);
+            }
+            // Delete checkpoint proposals for slots < oldestSlot, using checkpointProposalsForSlot as index
+            for await (const slot of this.checkpointProposalsForSlot.keysAsync({
+                end: oldestSlot
+            })){
+                const proposalIds = await toArray(this.checkpointProposalsForSlot.getValuesAsync(slot));
+                for (const proposalId of proposalIds){
+                    await this.checkpointProposals.delete(proposalId);
+                    numberOfCheckpointProposals++;
+                }
+                await this.checkpointProposalsForSlot.delete(slot);
+            }
+            // Delete block proposals for slots < oldestSlot, using blockProposalsForSlotAndIndex as index
+            // Key format: (slot << INDEX_BITS) | indexWithinCheckpoint
+            const blockPositionEndKey = oldestSlot << AttestationPool.INDEX_BITS;
+            for await (const positionKey of this.blockProposalsForSlotAndIndex.keysAsync({
+                end: blockPositionEndKey
+            })){
+                const proposalIds = await toArray(this.blockProposalsForSlotAndIndex.getValuesAsync(positionKey));
+                for (const proposalId of proposalIds){
+                    await this.blockProposals.delete(proposalId);
+                    numberOfBlockProposals++;
+                }
+                await this.blockProposalsForSlotAndIndex.delete(positionKey);
+            }
+        });
+        this.log.verbose(`Deleted old pool data`, {
+            oldestSlot,
+            numberOfAttestations,
+            numberOfCheckpointProposals,
+            numberOfBlockProposals
+        });
+    }
+    /**
+   * Attempts to add a checkpoint attestation to the pool.
+   *
+   * This method performs validation and addition in a single call:
+   * - Checks if the attestation already exists (returns alreadyExists: true if so)
+   * - Checks if this signer has reached the per-signer attestation cap for this slot
+   * - Adds the attestation if validation passes
+   *
+   * @param attestation - The checkpoint attestation to add
+   * @returns Result indicating whether the attestation was added, existence info, and count of
+   *          attestations by this signer for this slot (for equivocation detection)
+   */ async tryAddCheckpointAttestation(attestation) {
+        const slotNumber = attestation.payload.header.slotNumber;
+        const proposalId = attestation.archive.toString();
+        const sender = attestation.getSender();
+        if (!sender) {
+            return {
+                added: false,
+                alreadyExists: false,
+                count: 0
+            };
+        }
+        const signerAddress = sender.toString();
+        return await this.store.transactionAsync(async ()=>{
+            const key = this.getAttestationKey(slotNumber, proposalId, signerAddress);
+            const alreadyExists = await this.checkpointAttestations.hasAsync(key);
+            // Get count of attestations by this signer for this slot (for duplicate detection)
+            const signerAttestationCount = await this.getSignerAttestationCountForSlot(slotNumber, signerAddress);
+            if (alreadyExists) {
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    count: signerAttestationCount
+                };
+            }
+            // Check if this signer has exceeded the per-signer cap for this slot
+            if (signerAttestationCount >= MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER) {
+                this.log.debug(`Rejecting attestation: signer ${signerAddress} exceeded per-slot cap for slot ${slotNumber}`, {
+                    slotNumber,
+                    signerAddress,
+                    proposalId,
+                    signerAttestationCount
+                });
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    count: signerAttestationCount
+                };
+            }
+            // Add the attestation
+            await this.checkpointAttestations.set(key, attestation.toBuffer());
+            // Track this attestation in the per-signer-per-slot index for duplicate detection
+            const slotSignerKey = this.getSlotSignerKey(slotNumber, signerAddress);
+            await this.checkpointAttestationsPerSlotAndSigner.set(slotSignerKey, proposalId);
+            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${signerAddress}`, {
+                signature: attestation.signature.toString(),
+                slotNumber,
+                address: signerAddress,
+                proposalId
+            });
+            // Return the new count
+            return {
+                added: true,
+                alreadyExists: false,
+                count: signerAttestationCount + 1
+            };
+        });
+    }
+    /** Gets the count of attestations by a specific signer for a given slot. */ async getSignerAttestationCountForSlot(slot, signerAddress) {
+        const slotSignerKey = this.getSlotSignerKey(slot, signerAddress);
+        return await this.checkpointAttestationsPerSlotAndSigner.getValueCountAsync(slotSignerKey);
+    }
+}
+/** Creates an AttestationPool backed by a temporary store for testing. */ export async function createTestAttestationPool(telemetry) {
+    const { openTmpStore } = await import('@aztec/kv-store/lmdb-v2');
+    const store = await openTmpStore('test-attestation-pool');
+    return new AttestationPool(store, telemetry);
+}

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.d.ts

@@ -1,3 +1,3 @@
-import type { AttestationPool } from './attestation_pool.js';
+import { type AttestationPool } from './attestation_pool.js';
 export declare function describeAttestationPool(getAttestationPool: () => AttestationPool): void;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBTTdELHdCQUFnQix1QkFBdUIsQ0FBQyxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsUUEwV2hGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFDTCxLQUFLLGVBQWUsRUFHckIsTUFBTSx1QkFBdUIsQ0FBQztBQUsvQix3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBMnJCaEYifQ==

package/dest/mem_pools/attestation_pool/attestation_pool_test_suite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attestation_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool_test_suite.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAM7D,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA0WhF"}
+{"version":3,"file":"attestation_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool_test_suite.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,KAAK,eAAe,EAGrB,MAAM,uBAAuB,CAAC;AAK/B,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA2rBhF"}