@aztec/p2p 0.0.1-commit.e310a4c8 → 0.0.1-commit.e558bd1c

package/dest/mem_pools/attestation_pool/attestation_pool.js

@@ -1,6 +1,414 @@
+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_PROPOSALS_PER_SLOT = 5;
+export const MAX_PROPOSALS_PER_POSITION = 3;
+export const ATTESTATION_CAP_BUFFER = 10;
 /**
- * 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;
+    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');
+        // 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`
+        };
+    }
+    /** 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 totalForPosition = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    totalForPosition
+                };
+            }
+            // Get current count for position and check cap, do not add if exceeded
+            const totalForPosition = await this.getBlockProposalCountForPosition(blockProposal.slotNumber, blockProposal.indexWithinCheckpoint);
+            if (totalForPosition >= MAX_PROPOSALS_PER_POSITION) {
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    totalForPosition
+                };
+            }
+            // 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,
+                totalForPosition: totalForPosition + 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 totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    totalForPosition
+                };
+            }
+            // Get current count for slot and check cap
+            const totalForPosition = await this.checkpointProposalsForSlot.getValueCountAsync(proposal.slotNumber);
+            if (totalForPosition >= MAX_PROPOSALS_PER_SLOT) {
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    totalForPosition
+                };
+            }
+            // 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,
+                totalForPosition: totalForPosition + 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++;
+            }
+            // 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 the (slot, proposalId) has reached the attestation cap (returns added: false if so)
+   * - Adds the attestation if validation passes
+   *
+   * @param attestation - The checkpoint attestation to add
+   * @param committeeSize - Committee size for the attestation's slot
+   * @returns Result indicating whether the attestation was added and existence info
+   */ async tryAddCheckpointAttestation(attestation, committeeSize) {
+        const slotNumber = attestation.payload.header.slotNumber;
+        const proposalId = attestation.archive.toString();
+        const sender = attestation.getSender();
+        if (!sender) {
+            return {
+                added: false,
+                alreadyExists: false,
+                totalForPosition: 0
+            };
+        }
+        return await this.store.transactionAsync(async ()=>{
+            const key = this.getAttestationKey(slotNumber, proposalId, sender.toString());
+            const alreadyExists = await this.checkpointAttestations.hasAsync(key);
+            if (alreadyExists) {
+                const total = await this.getAttestationCount(slotNumber, proposalId);
+                return {
+                    added: false,
+                    alreadyExists: true,
+                    totalForPosition: total
+                };
+            }
+            const limit = committeeSize + ATTESTATION_CAP_BUFFER;
+            const currentCount = await this.getAttestationCount(slotNumber, proposalId);
+            if (currentCount >= limit) {
+                return {
+                    added: false,
+                    alreadyExists: false,
+                    totalForPosition: currentCount
+                };
+            }
+            await this.checkpointAttestations.set(key, attestation.toBuffer());
+            this.log.debug(`Added checkpoint attestation for slot ${slotNumber} from ${sender.toString()}`, {
+                signature: attestation.signature.toString(),
+                slotNumber,
+                address: sender.toString(),
+                proposalId
+            });
+            return {
+                added: true,
+                alreadyExists: false,
+                totalForPosition: currentCount + 1
+            };
+        });
+    }
+    /** Gets the count of attestations for a given (slot, proposalId). */ async getAttestationCount(slot, proposalId) {
+        const range = this.getAttestationKeyRangeForProposal(slot, proposalId);
+        let count = 0;
+        for await (const _ of this.checkpointAttestations.keysAsync(range)){
+            count++;
+        }
+        return count;
+    }
+}
+/** 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL2F0dGVzdGF0aW9uX3Bvb2wvYXR0ZXN0YXRpb25fcG9vbF90ZXN0X3N1aXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVlBLE9BQU8sRUFBRSxLQUFLLGVBQWUsRUFBc0QsTUFBTSx1QkFBdUIsQ0FBQztBQUtqSCx3QkFBZ0IsdUJBQXVCLENBQUMsa0JBQWtCLEVBQUUsTUFBTSxlQUFlLFFBMnJCaEYifQ==

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,EAAE,KAAK,eAAe,EAAsD,MAAM,uBAAuB,CAAC;AAKjH,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA2rBhF"}