@aztec/p2p 0.0.0-test.0

package/dest/client/p2p_client.js

@@ -0,0 +1,505 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { createLogger } from '@aztec/foundation/log';
+import { Attributes, TraceableL2BlockStream, WithTracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
+import { getP2PDefaultConfig } from '../config.js';
+import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
+/**
+ * Enum defining the possible states of the p2p client.
+ */ export var P2PClientState = /*#__PURE__*/ function(P2PClientState) {
+    P2PClientState[P2PClientState["IDLE"] = 0] = "IDLE";
+    P2PClientState[P2PClientState["SYNCHING"] = 1] = "SYNCHING";
+    P2PClientState[P2PClientState["RUNNING"] = 2] = "RUNNING";
+    P2PClientState[P2PClientState["STOPPED"] = 3] = "STOPPED";
+    return P2PClientState;
+}({});
+/**
+ * The P2P client implementation.
+ */ export class P2PClient extends WithTracer {
+    l2BlockSource;
+    p2pService;
+    log;
+    /** The JS promise that will be running to keep the client's data in sync. Can be interrupted if the client is stopped. */ runningPromise;
+    currentState;
+    syncPromise;
+    syncResolve;
+    latestBlockNumberAtStart;
+    provenBlockNumberAtStart;
+    synchedBlockHashes;
+    synchedLatestBlockNumber;
+    synchedProvenBlockNumber;
+    txPool;
+    attestationPool;
+    /** How many slots to keep attestations for. */ keepAttestationsInPoolFor;
+    /** How many slots to keep proven txs for. */ keepProvenTxsFor;
+    blockStream;
+    /**
+   * In-memory P2P client constructor.
+   * @param store - The client's instance of the KV store.
+   * @param l2BlockSource - P2P client's source for fetching existing blocks.
+   * @param txPool - The client's instance of a transaction pool. Defaults to in-memory implementation.
+   * @param p2pService - The concrete instance of p2p networking to use.
+   * @param keepProvenTxsFor - How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven).
+   * @param log - A logger.
+   */ constructor(_clientType, store, l2BlockSource, mempools, p2pService, config = {}, telemetry = getTelemetryClient(), log = createLogger('p2p')){
+        super(telemetry, 'P2PClient'), this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, this.log = log, this.currentState = 0, this.syncPromise = Promise.resolve(), this.syncResolve = undefined, this.latestBlockNumberAtStart = -1, this.provenBlockNumberAtStart = -1;
+        const { keepProvenTxsInPoolFor, blockCheckIntervalMS, blockRequestBatchSize, keepAttestationsInPoolFor } = {
+            ...getP2PDefaultConfig(),
+            ...config
+        };
+        this.keepProvenTxsFor = keepProvenTxsInPoolFor;
+        this.keepAttestationsInPoolFor = keepAttestationsInPoolFor;
+        const tracer = telemetry.getTracer('P2PL2BlockStream');
+        const logger = createLogger('p2p:l2-block-stream');
+        this.blockStream = new TraceableL2BlockStream(l2BlockSource, this, this, tracer, 'P2PL2BlockStream', logger, {
+            batchSize: blockRequestBatchSize,
+            pollIntervalMS: blockCheckIntervalMS
+        });
+        this.synchedBlockHashes = store.openMap('p2p_pool_block_hashes');
+        this.synchedLatestBlockNumber = store.openSingleton('p2p_pool_last_l2_block');
+        this.synchedProvenBlockNumber = store.openSingleton('p2p_pool_last_proven_l2_block');
+        this.txPool = mempools.txPool;
+        this.attestationPool = mempools.attestationPool;
+    }
+    isP2PClient() {
+        return true;
+    }
+    getPeers(includePending) {
+        return Promise.resolve(this.p2pService.getPeers(includePending));
+    }
+    getL2BlockHash(number) {
+        return this.synchedBlockHashes.getAsync(number);
+    }
+    async getL2Tips() {
+        const latestBlockNumber = await this.getSyncedLatestBlockNum();
+        let latestBlockHash;
+        const provenBlockNumber = await this.getSyncedProvenBlockNum();
+        let provenBlockHash;
+        if (latestBlockNumber > 0) {
+            latestBlockHash = await this.synchedBlockHashes.getAsync(latestBlockNumber);
+            if (typeof latestBlockHash === 'undefined') {
+                this.log.warn(`Block hash for latest block ${latestBlockNumber} not found`);
+                throw new Error();
+            }
+        }
+        if (provenBlockNumber > 0) {
+            provenBlockHash = await this.synchedBlockHashes.getAsync(provenBlockNumber);
+            if (typeof provenBlockHash === 'undefined') {
+                this.log.warn(`Block hash for proven block ${provenBlockNumber} not found`);
+                throw new Error();
+            }
+        }
+        return Promise.resolve({
+            latest: {
+                hash: latestBlockHash,
+                number: latestBlockNumber
+            },
+            proven: {
+                hash: provenBlockHash,
+                number: provenBlockNumber
+            },
+            finalized: {
+                hash: provenBlockHash,
+                number: provenBlockNumber
+            }
+        });
+    }
+    async handleBlockStreamEvent(event) {
+        this.log.debug(`Handling block stream event ${event.type}`);
+        switch(event.type){
+            case 'blocks-added':
+                await this.handleLatestL2Blocks(event.blocks);
+                break;
+            case 'chain-finalized':
+                break;
+            case 'chain-proven':
+                {
+                    const from = await this.getSyncedProvenBlockNum() + 1;
+                    const limit = event.blockNumber - from + 1;
+                    await this.handleProvenL2Blocks(await this.l2BlockSource.getBlocks(from, limit));
+                    break;
+                }
+            case 'chain-pruned':
+                await this.handlePruneL2Blocks(event.blockNumber);
+                break;
+            default:
+                {
+                    const _ = event;
+                    break;
+                }
+        }
+    }
+    #assertIsReady() {
+        // this.log.info('Checking if p2p client is ready, current state: ', this.currentState);
+        if (!this.isReady()) {
+            throw new Error('P2P client not ready');
+        }
+    }
+    /**
+   * Starts the P2P client.
+   * @returns An empty promise signalling the synching process.
+   */ async start() {
+        if (this.currentState === 3) {
+            throw new Error('P2P client already stopped');
+        }
+        if (this.currentState !== 0) {
+            return this.syncPromise;
+        }
+        // get the current latest block numbers
+        this.latestBlockNumberAtStart = await this.l2BlockSource.getBlockNumber();
+        this.provenBlockNumberAtStart = await this.l2BlockSource.getProvenBlockNumber();
+        const syncedLatestBlock = await this.getSyncedLatestBlockNum() + 1;
+        const syncedProvenBlock = await this.getSyncedProvenBlockNum() + 1;
+        // if there are blocks to be retrieved, go to a synching state
+        if (syncedLatestBlock <= this.latestBlockNumberAtStart || syncedProvenBlock <= this.provenBlockNumberAtStart) {
+            this.setCurrentState(1);
+            this.syncPromise = new Promise((resolve)=>{
+                this.syncResolve = resolve;
+            });
+            this.log.verbose(`Starting sync from ${syncedLatestBlock} (last proven ${syncedProvenBlock})`);
+        } else {
+            // if no blocks to be retrieved, go straight to running
+            this.setCurrentState(2);
+            this.syncPromise = Promise.resolve();
+            await this.p2pService.start();
+            this.log.debug(`Block ${syncedLatestBlock} (proven ${syncedProvenBlock}) already beyond current block`);
+        }
+        this.blockStream.start();
+        this.log.verbose(`Started block downloader from block ${syncedLatestBlock}`);
+        return this.syncPromise;
+    }
+    /**
+   * Allows consumers to stop the instance of the P2P client.
+   * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+   */ async stop() {
+        this.log.debug('Stopping p2p client...');
+        await this.p2pService.stop();
+        this.log.debug('Stopped p2p service');
+        await this.blockStream.stop();
+        this.log.debug('Stopped block downloader');
+        await this.runningPromise;
+        this.setCurrentState(3);
+        this.log.info('P2P client stopped.');
+    }
+    broadcastProposal(proposal) {
+        this.log.verbose(`Broadcasting proposal for slot ${proposal.slotNumber.toNumber()} to peers`);
+        return this.p2pService.propagate(proposal);
+    }
+    async getAttestationsForSlot(slot, proposalId) {
+        return await this.attestationPool?.getAttestationsForSlot(slot, proposalId) ?? [];
+    }
+    // REVIEW: https://github.com/AztecProtocol/aztec-packages/issues/7963
+    // ^ This pattern is not my favorite (md)
+    registerBlockProposalHandler(handler) {
+        this.p2pService.registerBlockReceivedCallback(handler);
+    }
+    /**
+   * Requests the transactions with the given hashes from the network.
+   *
+   * If a transaction can be retrieved, it will be returned, if not an undefined
+   * will be returned. In place.
+   *
+   * @param txHashes - The hashes of the transactions to request.
+   * @returns A promise that resolves to an array of transactions or undefined.
+   */ async requestTxs(txHashes) {
+        const res = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes);
+        return Promise.resolve(res ?? []);
+    }
+    /**
+   * Uses the Request Response protocol to request a transaction from the network.
+   *
+   * If the underlying request response protocol fails, then we return undefined.
+   * If it succeeds then we add the transaction to our transaction pool and return.
+   *
+   * @param txHash - The hash of the transaction to request.
+   * @returns A promise that resolves to a transaction or undefined.
+   */ async requestTxByHash(txHash) {
+        const tx = await this.p2pService.sendRequest(ReqRespSubProtocol.TX, txHash);
+        if (tx) {
+            this.log.debug(`Received tx ${txHash.toString()} from peer`);
+            await this.txPool.addTxs([
+                tx
+            ]);
+        } else {
+            this.log.debug(`Failed to receive tx ${txHash.toString()} from peer`);
+        }
+        return tx;
+    }
+    /**
+   * Uses the batched Request Response protocol to request a set of transactions from the network.
+   */ async requestTxsByHash(txHashes) {
+        const txs = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes) ?? [];
+        await this.txPool.addTxs(txs);
+        const txHashesStr = txHashes.map((tx)=>tx.toString()).join(', ');
+        this.log.debug(`Received batched txs ${txHashesStr} (${txs.length} / ${txHashes.length}}) from peers`);
+        return txs;
+    }
+    getPendingTxs() {
+        return Promise.resolve(this.getTxs('pending'));
+    }
+    async getPendingTxCount() {
+        const pendingTxs = await this.txPool.getPendingTxHashes();
+        return pendingTxs.length;
+    }
+    async *iteratePendingTxs() {
+        for (const txHash of (await this.txPool.getPendingTxHashes())){
+            const tx = await this.txPool.getTxByHash(txHash);
+            if (tx) {
+                yield tx;
+            }
+        }
+    }
+    /**
+   * Returns all transactions in the transaction pool.
+   * @returns An array of Txs.
+   */ async getTxs(filter) {
+        if (filter === 'all') {
+            return this.txPool.getAllTxs();
+        } else if (filter === 'mined') {
+            const minedHashes = await this.txPool.getMinedTxHashes();
+            const minedTx = await Promise.all(minedHashes.map(([txHash])=>this.txPool.getTxByHash(txHash)));
+            return minedTx.filter((tx)=>!!tx);
+        } else if (filter === 'pending') {
+            const pendingHashses = await this.txPool.getPendingTxHashes();
+            const pendingTxs = await Promise.all(pendingHashses.map((txHash)=>this.txPool.getTxByHash(txHash)));
+            return pendingTxs.filter((tx)=>!!tx);
+        } else {
+            const _ = filter;
+            throw new Error(`Unknown filter ${filter}`);
+        }
+    }
+    /**
+   * Returns a transaction in the transaction pool by its hash.
+   * @param txHash - Hash of the transaction to look for in the pool.
+   * @returns A single tx or undefined.
+   */ getTxByHashFromPool(txHash) {
+        return this.txPool.getTxByHash(txHash);
+    }
+    /**
+   * Returns a transaction in the transaction pool by its hash.
+   * If the transaction is not in the pool, it will be requested from the network.
+   * @param txHash - Hash of the transaction to look for in the pool.
+   * @returns A single tx or undefined.
+   */ async getTxByHash(txHash) {
+        const tx = await this.txPool.getTxByHash(txHash);
+        if (tx) {
+            return tx;
+        }
+        return this.requestTxByHash(txHash);
+    }
+    /**
+   * Returns transactions in the transaction pool by hash.
+   * If a transaction is not in the pool, it will be requested from the network.
+   * @param txHashes - Hashes of the transactions to look for.
+   * @returns The txs found, not necessarily on the same order as the hashes.
+   */ async getTxsByHash(txHashes) {
+        const txs = await Promise.all(txHashes.map((txHash)=>this.txPool.getTxByHash(txHash)));
+        const missingTxHashes = txs.map((tx, index)=>[
+                tx,
+                index
+            ]).filter(([tx, _index])=>!tx).map(([_tx, index])=>txHashes[index]);
+        if (missingTxHashes.length === 0) {
+            return txs;
+        }
+        const missingTxs = await this.requestTxsByHash(missingTxHashes);
+        return txs.filter((tx)=>!!tx).concat(missingTxs);
+    }
+    /**
+   * Returns an archived transaction in the transaction pool by its hash.
+   * @param txHash - Hash of the archived transaction to look for.
+   * @returns A single tx or undefined.
+   */ getArchivedTxByHash(txHash) {
+        return this.txPool.getArchivedTxByHash(txHash);
+    }
+    /**
+   * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
+   * @param tx - The tx to verify.
+   * @returns Empty promise.
+   **/ async sendTx(tx) {
+        this.#assertIsReady();
+        await this.txPool.addTxs([
+            tx
+        ]);
+        this.p2pService.propagate(tx);
+    }
+    /**
+   * Returns whether the given tx hash is flagged as pending or mined.
+   * @param txHash - Hash of the tx to query.
+   * @returns Pending or mined depending on its status, or undefined if not found.
+   */ getTxStatus(txHash) {
+        return this.txPool.getTxStatus(txHash);
+    }
+    getEnr() {
+        return this.p2pService.getEnr();
+    }
+    getEncodedEnr() {
+        return Promise.resolve(this.p2pService.getEnr()?.encodeTxt());
+    }
+    /**
+   * Deletes the 'txs' from the pool.
+   * NOT used if we use sendTx as reconcileTxPool will handle this.
+   * @param txHashes - Hashes of the transactions to delete.
+   * @returns Empty promise.
+   **/ async deleteTxs(txHashes) {
+        this.#assertIsReady();
+        await this.txPool.deleteTxs(txHashes);
+    }
+    /**
+   * Public function to check if the p2p client is fully synced and ready to receive txs.
+   * @returns True if the P2P client is ready to receive txs.
+   */ isReady() {
+        return this.currentState === 2;
+    }
+    /**
+   * Public function to check the latest block number that the P2P client is synced to.
+   * @returns Block number of latest L2 Block we've synced with.
+   */ async getSyncedLatestBlockNum() {
+        return await this.synchedLatestBlockNumber.getAsync() ?? INITIAL_L2_BLOCK_NUM - 1;
+    }
+    /**
+   * Public function to check the latest proven block number that the P2P client is synced to.
+   * @returns Block number of latest proven L2 Block we've synced with.
+   */ async getSyncedProvenBlockNum() {
+        return await this.synchedProvenBlockNumber.getAsync() ?? INITIAL_L2_BLOCK_NUM - 1;
+    }
+    /**
+   * Method to check the status the p2p client.
+   * @returns Information about p2p client status: state & syncedToBlockNum.
+   */ async getStatus() {
+        const blockNumber = await this.getSyncedLatestBlockNum();
+        const blockHash = blockNumber === 0 ? '' : await this.l2BlockSource.getBlockHeader(blockNumber).then((header)=>header?.hash()).then((hash)=>hash?.toString());
+        return {
+            state: this.currentState,
+            syncedToL2Block: {
+                number: blockNumber,
+                hash: blockHash
+            }
+        };
+    }
+    /**
+   * Mark all txs from these blocks as mined.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */ async markTxsAsMinedFromBlocks(blocks) {
+        for (const block of blocks){
+            const txHashes = block.body.txEffects.map((txEffect)=>txEffect.txHash);
+            await this.txPool.markAsMined(txHashes, block.number);
+        }
+    }
+    /**
+   * Deletes txs from these blocks.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */ async deleteTxsFromBlocks(blocks) {
+        this.log.debug(`Deleting txs from blocks ${blocks[0].number} to ${blocks[blocks.length - 1].number}`);
+        for (const block of blocks){
+            const txHashes = block.body.txEffects.map((txEffect)=>txEffect.txHash);
+            await this.txPool.deleteTxs(txHashes);
+        }
+    }
+    /**
+   * Handles new mined blocks by marking the txs in them as mined.
+   * @param blocks - A list of existing blocks with txs that the P2P client needs to ensure the tx pool is reconciled with.
+   * @returns Empty promise.
+   */ async handleLatestL2Blocks(blocks) {
+        if (!blocks.length) {
+            return Promise.resolve();
+        }
+        await this.markTxsAsMinedFromBlocks(blocks);
+        const lastBlockNum = blocks[blocks.length - 1].number;
+        await Promise.all(blocks.map(async (block)=>this.synchedBlockHashes.set(block.number, (await block.hash()).toString())));
+        await this.synchedLatestBlockNumber.set(lastBlockNum);
+        this.log.verbose(`Synched to latest block ${lastBlockNum}`);
+        await this.startServiceIfSynched();
+    }
+    /**
+   * Handles new proven blocks by deleting the txs in them, or by deleting the txs in blocks `keepProvenTxsFor` ago.
+   * @param blocks - A list of proven L2 blocks.
+   * @returns Empty promise.
+   */ async handleProvenL2Blocks(blocks) {
+        if (!blocks.length) {
+            return Promise.resolve();
+        }
+        const firstBlockNum = blocks[0].number;
+        const lastBlockNum = blocks[blocks.length - 1].number;
+        const lastBlockSlot = blocks[blocks.length - 1].header.globalVariables.slotNumber.toBigInt();
+        // If keepProvenTxsFor is 0, we delete all txs from all proven blocks.
+        if (this.keepProvenTxsFor === 0) {
+            await this.deleteTxsFromBlocks(blocks);
+        } else if (lastBlockNum - this.keepProvenTxsFor >= INITIAL_L2_BLOCK_NUM) {
+            const fromBlock = Math.max(INITIAL_L2_BLOCK_NUM, firstBlockNum - this.keepProvenTxsFor);
+            const toBlock = lastBlockNum - this.keepProvenTxsFor;
+            const limit = toBlock - fromBlock + 1;
+            const blocksToDeleteTxsFrom = await this.l2BlockSource.getBlocks(fromBlock, limit, true);
+            await this.deleteTxsFromBlocks(blocksToDeleteTxsFrom);
+        }
+        // We delete attestations older than the last block slot minus the number of slots we want to keep in the pool.
+        const lastBlockSlotMinusKeepAttestationsInPoolFor = lastBlockSlot - BigInt(this.keepAttestationsInPoolFor);
+        if (lastBlockSlotMinusKeepAttestationsInPoolFor >= BigInt(INITIAL_L2_BLOCK_NUM)) {
+            await this.attestationPool?.deleteAttestationsOlderThan(lastBlockSlotMinusKeepAttestationsInPoolFor);
+        }
+        await this.synchedProvenBlockNumber.set(lastBlockNum);
+        this.log.debug(`Synched to proven block ${lastBlockNum}`);
+        await this.startServiceIfSynched();
+    }
+    /**
+   * Updates the tx pool after a chain prune.
+   * @param latestBlock - The block number the chain was pruned to.
+   */ async handlePruneL2Blocks(latestBlock) {
+        const txsToDelete = [];
+        for (const tx of (await this.txPool.getAllTxs())){
+            // every tx that's been generated against a block that has now been pruned is no longer valid
+            if (tx.data.constants.historicalHeader.globalVariables.blockNumber.toNumber() > latestBlock) {
+                txsToDelete.push(await tx.getTxHash());
+            }
+        }
+        this.log.info(`Detected chain prune. Removing invalid txs count=${txsToDelete.length} newLatestBlock=${latestBlock} previousLatestBlock=${this.getSyncedLatestBlockNum()}`);
+        // delete invalid txs (both pending and mined)
+        await this.txPool.deleteTxs(txsToDelete);
+        // everything left in the mined set was built against a block on the proven chain so its still valid
+        // move back to pending the txs that were reorged out of the chain
+        // NOTE: we can't move _all_ txs back to pending because the tx pool could keep hold of mined txs for longer
+        // (see this.keepProvenTxsFor)
+        const txsToMoveToPending = [];
+        for (const [txHash, blockNumber] of (await this.txPool.getMinedTxHashes())){
+            if (blockNumber > latestBlock) {
+                txsToMoveToPending.push(txHash);
+            }
+        }
+        this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
+        await this.txPool.markMinedAsPending(txsToMoveToPending);
+        await this.synchedLatestBlockNumber.set(latestBlock);
+    // no need to update block hashes, as they will be updated as new blocks are added
+    }
+    async startServiceIfSynched() {
+        if (this.currentState === 1 && await this.getSyncedLatestBlockNum() >= this.latestBlockNumberAtStart && await this.getSyncedProvenBlockNum() >= this.provenBlockNumberAtStart) {
+            this.log.debug(`Synched to blocks at start`);
+            this.setCurrentState(2);
+            if (this.syncResolve !== undefined) {
+                this.syncResolve();
+                await this.p2pService.start();
+            }
+        }
+    }
+    /**
+   * Method to set the value of the current state.
+   * @param newState - New state value.
+   */ setCurrentState(newState) {
+        const oldState = this.currentState;
+        this.currentState = newState;
+        this.log.debug(`Moved from state ${P2PClientState[oldState]} to ${P2PClientState[this.currentState]}`);
+    }
+}
+_ts_decorate([
+    trackSpan('p2pClient.broadcastProposal', async (proposal)=>({
+            [Attributes.BLOCK_NUMBER]: proposal.blockNumber.toNumber(),
+            [Attributes.SLOT_NUMBER]: proposal.slotNumber.toNumber(),
+            [Attributes.BLOCK_ARCHIVE]: proposal.archive.toString(),
+            [Attributes.P2P_ID]: (await proposal.p2pMessageIdentifier()).toString()
+        }))
+], P2PClient.prototype, "broadcastProposal", null);

package/dest/config.d.ts

@@ -0,0 +1,180 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { type ChainConfig } from '@aztec/stdlib/config';
+import { type P2PReqRespConfig } from './services/reqresp/config.js';
+/**
+ * P2P client configuration values.
+ */
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
+    /**
+     * A flag dictating whether the P2P subsystem should be enabled.
+     */
+    p2pEnabled: boolean;
+    /**
+     * The frequency in which to check for new L2 blocks.
+     */
+    blockCheckIntervalMS: number;
+    /**
+     * The number of blocks to fetch in a single batch.
+     */
+    blockRequestBatchSize: number;
+    /**
+     * DEBUG: Disable colocation penalty - for testing purposes only
+     */
+    debugDisableColocationPenalty: boolean;
+    /**
+     * The frequency in which to check for new peers.
+     */
+    peerCheckIntervalMS: number;
+    /**
+     * Size of queue of L2 blocks to store.
+     */
+    l2QueueSize: number;
+    /**
+     * The announce address for TCP.
+     */
+    tcpAnnounceAddress?: string;
+    /**
+     * The announce address for UDP.
+     */
+    udpAnnounceAddress?: string;
+    /**
+     * The listen address for TCP.
+     */
+    tcpListenAddress: string;
+    /**
+     * The listen address for UDP.
+     */
+    udpListenAddress: string;
+    /**
+     * An optional peer id private key. If blank, will generate a random key.
+     */
+    peerIdPrivateKey?: string;
+    /**
+     * A list of bootstrap peers to connect to.
+     */
+    bootstrapNodes: string[];
+    /** Whether to execute the version check in the bootstrap node ENR. */
+    bootstrapNodeEnrVersionCheck: boolean;
+    /** Whether to consider any configured bootnodes as full peers, e.g. for transaction gossiping */
+    bootstrapNodesAsFullPeers: boolean;
+    /**
+     * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
+     */
+    maxPeerCount: number;
+    /**
+     * If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.
+     */
+    queryForIp: boolean;
+    /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
+    keepProvenTxsInPoolFor: number;
+    /** How many slots to keep attestations for. */
+    keepAttestationsInPoolFor: number;
+    /**
+     * The interval of the gossipsub heartbeat to perform maintenance tasks.
+     */
+    gossipsubInterval: number;
+    /**
+     * The D parameter for the gossipsub protocol.
+     */
+    gossipsubD: number;
+    /**
+     * The Dlo parameter for the gossipsub protocol.
+     */
+    gossipsubDlo: number;
+    /**
+     * The Dhi parameter for the gossipsub protocol.
+     */
+    gossipsubDhi: number;
+    /**
+     * The Dlazy parameter for the gossipsub protocol.
+     */
+    gossipsubDLazy: number;
+    /**
+     * Whether to flood publish messages. - For testing purposes only
+     */
+    gossipsubFloodPublish: boolean;
+    /**
+     * The number of gossipsub interval message cache windows to keep.
+     */
+    gossipsubMcacheLength: number;
+    /**
+     * How many message cache windows to include when gossiping with other pears.
+     */
+    gossipsubMcacheGossip: number;
+    /**
+     * The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it.
+     */
+    doubleSpendSeverePeerPenaltyWindow: number;
+    /**
+     * The weight of the tx topic for the gossipsub protocol.  This determines how much the score for this specific topic contributes to the overall peer score.
+     */
+    gossipsubTxTopicWeight: number;
+    /**
+     * This is the weight applied to the penalty for delivering invalid messages.
+     */
+    gossipsubTxInvalidMessageDeliveriesWeight: number;
+    /**
+     * determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.
+     */
+    gossipsubTxInvalidMessageDeliveriesDecay: number;
+    /**
+     * The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.
+     */
+    peerPenaltyValues: number[];
+    /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
+    archivedTxLimit: number;
+}
+export declare const p2pConfigMappings: ConfigMappingsType<P2PConfig>;
+/**
+ * Gets the config values for p2p client from environment variables.
+ * @returns The config values for p2p client.
+ */
+export declare function getP2PConfigFromEnv(): P2PConfig;
+export declare function getP2PDefaultConfig(): P2PConfig;
+/**
+ * Required P2P config values for a bootstrap node.
+ */
+export type BootnodeConfig = Pick<P2PConfig, 'udpAnnounceAddress' | 'peerIdPrivateKey' | 'bootstrapNodes'> & Required<Pick<P2PConfig, 'udpListenAddress'>> & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> & Pick<ChainConfig, 'l1ChainId'>;
+export declare const bootnodeConfigMappings: ConfigMappingsType<Pick<{
+    l1ChainId: unknown;
+    version: unknown;
+    l1Contracts: unknown;
+    dataDirectory: unknown;
+    dataStoreMapSizeKB: unknown;
+    overallRequestTimeoutMs: unknown;
+    individualRequestTimeoutMs: unknown;
+    p2pEnabled: unknown;
+    blockCheckIntervalMS: unknown;
+    blockRequestBatchSize: unknown;
+    debugDisableColocationPenalty: unknown;
+    peerCheckIntervalMS: unknown;
+    l2QueueSize: unknown;
+    tcpAnnounceAddress: unknown;
+    udpAnnounceAddress: unknown;
+    tcpListenAddress: unknown;
+    udpListenAddress: unknown;
+    peerIdPrivateKey: unknown;
+    bootstrapNodes: unknown;
+    bootstrapNodeEnrVersionCheck: unknown;
+    bootstrapNodesAsFullPeers: unknown;
+    maxPeerCount: unknown;
+    queryForIp: unknown;
+    keepProvenTxsInPoolFor: unknown;
+    keepAttestationsInPoolFor: unknown;
+    gossipsubInterval: unknown;
+    gossipsubD: unknown;
+    gossipsubDlo: unknown;
+    gossipsubDhi: unknown;
+    gossipsubDLazy: unknown;
+    gossipsubFloodPublish: unknown;
+    gossipsubMcacheLength: unknown;
+    gossipsubMcacheGossip: unknown;
+    doubleSpendSeverePeerPenaltyWindow: unknown;
+    gossipsubTxTopicWeight: unknown;
+    gossipsubTxInvalidMessageDeliveriesWeight: unknown;
+    gossipsubTxInvalidMessageDeliveriesDecay: unknown;
+    peerPenaltyValues: unknown;
+    archivedTxLimit: unknown;
+}, "udpAnnounceAddress" | "udpListenAddress" | "peerIdPrivateKey" | "bootstrapNodes" | "l1ChainId" | "dataDirectory" | "dataStoreMapSizeKB">>;
+//# sourceMappingURL=config.d.ts.map

package/dest/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,sBAAsB,CAAC;AAE7E,OAAO,EAAE,KAAK,gBAAgB,EAA4B,MAAM,8BAA8B,CAAC;AAE/F;;GAEG;AACH,MAAM,WAAW,SAAU,SAAQ,gBAAgB,EAAE,WAAW;IAC9D;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;OAEG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,6BAA6B,EAAE,OAAO,CAAC;IAEvC;;OAEG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,cAAc,EAAE,MAAM,EAAE,CAAC;IAEzB,sEAAsE;IACtE,4BAA4B,EAAE,OAAO,CAAC;IAEtC,iGAAiG;IACjG,yBAAyB,EAAE,OAAO,CAAC;IAEnC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,UAAU,EAAE,OAAO,CAAC;IAEpB,+HAA+H;IAC/H,sBAAsB,EAAE,MAAM,CAAC;IAE/B,+CAA+C;IAC/C,yBAAyB,EAAE,MAAM,CAAC;IAElC;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAE/B;;OAEG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;OAEG;IACH,kCAAkC,EAAE,MAAM,CAAC;IAE3C;;OAEG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAE/B;;OAEG;IACH,yCAAyC,EAAE,MAAM,CAAC;IAElD;;OAEG;IACH,wCAAwC,EAAE,MAAM,CAAC;IAEjD;;OAEG;IACH,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAE5B,sIAAsI;IACtI,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,SAAS,CAuK3D,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,CAE/C;AAED,wBAAgB,mBAAmB,IAAI,SAAS,CAE/C;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,EAAE,oBAAoB,GAAG,kBAAkB,GAAG,gBAAgB,CAAC,GACxG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAC,GAC7C,IAAI,CAAC,eAAe,EAAE,eAAe,GAAG,oBAAoB,CAAC,GAC7D,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;AAYjC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6IAGlC,CAAC"}