@aztec/p2p 1.2.1 → 2.0.0-nightly.20250813

package/dest/client/p2p_client.js

@@ -6,10 +6,14 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { getTimestampForSlot } from '@aztec/stdlib/epoch-helpers';
+import { tryStop } from '@aztec/stdlib/interfaces/server';
 import { Attributes, TraceableL2BlockStream, WithTracer, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 import { getP2PDefaultConfig } from '../config.js';
 import { ReqRespSubProtocol } from '../services/reqresp/interface.js';
-import { TxCollector } from '../services/tx_collector.js';
+import { chunkTxHashesRequest } from '../services/reqresp/protocols/tx.js';
+import { TxProvider } from '../services/tx_provider.js';
 import { P2PClientState } from './interface.js';
 /**
  * The P2P client implementation.
@@ -17,6 +21,8 @@ import { P2PClientState } from './interface.js';
     store;
     l2BlockSource;
     p2pService;
+    txCollection;
+    _dateProvider;
     telemetry;
     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;
@@ -35,6 +41,8 @@ import { P2PClientState } from './interface.js';
     attestationPool;
     config;
     blockStream;
+    txProvider;
+    validatorAddresses;
     /**
    * In-memory P2P client constructor.
    * @param store - The client's instance of the KV store.
@@ -42,20 +50,29 @@ import { P2PClientState } from './interface.js';
    * @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 log - A logger.
-   */ constructor(_clientType, store, l2BlockSource, mempools, p2pService, config = {}, telemetry = getTelemetryClient(), log = createLogger('p2p')){
-        super(telemetry, 'P2PClient'), this.store = store, this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, this.telemetry = telemetry, this.log = log, this.currentState = P2PClientState.IDLE, this.syncPromise = Promise.resolve(), this.syncResolve = undefined, this.latestBlockNumberAtStart = -1, this.provenBlockNumberAtStart = -1, this.finalizedBlockNumberAtStart = -1;
+   */ constructor(_clientType, store, l2BlockSource, mempools, p2pService, txCollection, config = {}, _dateProvider = new DateProvider(), telemetry = getTelemetryClient(), log = createLogger('p2p')){
+        super(telemetry, 'P2PClient'), this.store = store, this.l2BlockSource = l2BlockSource, this.p2pService = p2pService, this.txCollection = txCollection, this._dateProvider = _dateProvider, this.telemetry = telemetry, this.log = log, this.currentState = P2PClientState.IDLE, this.syncPromise = Promise.resolve(), this.syncResolve = undefined, this.latestBlockNumberAtStart = -1, this.provenBlockNumberAtStart = -1, this.finalizedBlockNumberAtStart = -1, this.validatorAddresses = [];
         this.config = {
             ...getP2PDefaultConfig(),
             ...config
         };
         this.txPool = mempools.txPool;
         this.attestationPool = mempools.attestationPool;
+        this.txProvider = new TxProvider(this.txCollection, this.txPool, this, this.log.createChild('tx-provider'), this.telemetry);
         // Default to collecting all txs when we see a valid proposal
-        // This can be overridden by the validator client to attest, and it will call collectForBlockProposal on its own
-        const txCollector = new TxCollector(this, this.log);
+        // This can be overridden by the validator client to attest, and it will call getTxsForBlockProposal on its own
+        // TODO(palla/txs): We should not trigger a request for txs on a proposal before fully validating it. We need to bring
+        // validator-client code into here so we can validate a proposal is reasonable.
         this.registerBlockProposalHandler(async (block, sender)=>{
             this.log.debug(`Received block proposal from ${sender.toString()}`);
-            await txCollector.collectForBlockProposal(block, sender);
+            // TODO(palla/txs): Need to subtract validatorReexecuteDeadlineMs from this deadline (see ValidatorClient.getReexecutionDeadline)
+            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
+            });
             return undefined;
         });
         // REFACTOR: Try replacing these with an L2TipsStore
@@ -65,12 +82,21 @@ import { P2PClientState } from './interface.js';
         this.synchedFinalizedBlockNumber = store.openSingleton('p2p_pool_last_finalized_l2_block');
         this.synchedLatestSlot = store.openSingleton('p2p_pool_last_l2_slot');
     }
+    registerThisValidatorAddresses(addresses) {
+        this.validatorAddresses = [
+            ...addresses
+        ];
+        this.p2pService.registerThisValidatorAddresses(this.validatorAddresses);
+    }
     clear() {
         return this.store.clear();
     }
     isP2PClient() {
         return true;
     }
+    getTxProvider() {
+        return this.txProvider;
+    }
     getPeers(includePending) {
         return Promise.resolve(this.p2pService.getPeers(includePending));
     }
@@ -142,11 +168,13 @@ import { P2PClientState } from './interface.js';
             case 'chain-proven':
                 {
                     await this.setBlockHash(event.block);
+                    this.txCollection.stopCollectingForBlocksUpTo(event.block.number);
                     await this.synchedProvenBlockNumber.set(event.block.number);
                     break;
                 }
             case 'chain-pruned':
                 await this.setBlockHash(event.block);
+                this.txCollection.stopCollectingForBlocksAfter(event.block.number);
                 await this.handlePruneL2Blocks(event.block.number);
                 break;
             default:
@@ -218,8 +246,12 @@ import { P2PClientState } from './interface.js';
             });
         }
         this.blockStream.start();
+        await this.txCollection.start();
         return this.syncPromise;
     }
+    addReqRespSubProtocol(subProtocol, handler, validator) {
+        return this.p2pService.addReqRespSubProtocol(subProtocol, handler, validator);
+    }
     initBlockStream(startingBlock) {
         if (!this.blockStream) {
             const { blockRequestBatchSize: batchSize, blockCheckIntervalMS: pollIntervalMS } = this.config;
@@ -235,6 +267,8 @@ import { P2PClientState } from './interface.js';
    * '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 tryStop(this.txCollection);
+        this.log.debug('Stopped tx collection service');
         await this.p2pService.stop();
         this.log.debug('Stopped p2p service');
         await this.blockStream?.stop();
@@ -263,39 +297,19 @@ import { P2PClientState } from './interface.js';
         this.p2pService.registerBlockReceivedCallback(handler);
     }
     /**
-   * 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, pinnedPeerId) {
         const timeoutMs = 8000; // Longer timeout for now
-        const maxPeers = Math.min(Math.ceil(txHashes.length / 3), 10);
         const maxRetryAttempts = 10; // Keep retrying within the timeout
-        const txs = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, txHashes, pinnedPeerId, timeoutMs, maxPeers, maxRetryAttempts);
-        // Some transactions may return undefined, so we filter them out
-        const filteredTxs = txs.filter((tx)=>!!tx);
-        if (filteredTxs.length > 0) {
-            await this.txPool.addTxs(filteredTxs);
+        const requests = chunkTxHashesRequest(txHashes);
+        const maxPeers = Math.min(Math.ceil(requests.length / 3), 10);
+        const txBatches = await this.p2pService.sendBatchRequest(ReqRespSubProtocol.TX, requests, pinnedPeerId, timeoutMs, maxPeers, maxRetryAttempts);
+        const txs = txBatches.flat();
+        if (txs.length > 0) {
+            await this.txPool.addTxs(txs);
         }
         const txHashesStr = txHashes.map((tx)=>tx.toString()).join(', ');
-        this.log.debug(`Requested txs ${txHashesStr} (${filteredTxs.length} / ${txHashes.length}) from peers`);
+        this.log.debug(`Requested txs ${txHashesStr} (${txs.length} / ${txHashes.length}) from peers`);
         // We return all transactions, even the not found ones to the caller, such they can handle missing items themselves.
         return txs;
     }
@@ -378,18 +392,6 @@ import { P2PClientState } from './interface.js';
         return this.txPool.hasTxs(txHashes);
     }
     /**
-   * 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.
@@ -404,26 +406,26 @@ import { P2PClientState } from './interface.js';
             return txs;
         }
         const missingTxs = await this.requestTxsByHash(missingTxHashes, pinnedPeerId);
-        const fetchedMissingTxs = missingTxs.filter((tx)=>!!tx);
         // TODO: optimize
         // Merge the found txs in order
-        const mergingTxsPromises = txHashes.map(async (txHash)=>{
+        const mergingTxs = txHashes.map((txHash)=>{
             // Is it in the txs list from the mempool?
             for (const tx of txs){
-                if (tx !== undefined && (await tx.getTxHash()).equals(txHash)) {
+                if (tx !== undefined && tx.getTxHash().equals(txHash)) {
                     return tx;
                 }
             }
             // Is it in the fetched missing txs?
-            for (const tx of fetchedMissingTxs){
-                if (tx !== undefined && (await tx.getTxHash()).equals(txHash)) {
+            // Note: this is an O(n^2) operation, but we expect the number of missing txs to be small.
+            for (const tx of missingTxs){
+                if (tx.getTxHash().equals(txHash)) {
                     return tx;
                 }
             }
             // Otherwise return undefined
             return undefined;
         });
-        return await Promise.all(mergingTxsPromises);
+        return mergingTxs;
     }
     /**
    * Returns an archived transaction in the transaction pool by its hash.
@@ -542,7 +544,7 @@ import { P2PClientState } from './interface.js';
             return Promise.resolve();
         }
         await this.markTxsAsMinedFromBlocks(blocks.map((b)=>b.block));
-        void this.requestMissingTxsFromUnprovenBlocks(blocks.map((b)=>b.block));
+        await this.startCollectingMissingTxs(blocks.map((b)=>b.block));
         const lastBlock = blocks.at(-1).block;
         await Promise.all(blocks.map(async (block)=>this.setBlockHash({
                 number: block.block.number,
@@ -553,23 +555,30 @@ import { P2PClientState } from './interface.js';
         this.log.verbose(`Synched to latest block ${lastBlock.number}`);
         await this.startServiceIfSynched();
     }
-    /** Request txs for unproven blocks so the prover node has more chances to get them. */ async requestMissingTxsFromUnprovenBlocks(blocks) {
+    /** Request txs for unproven blocks so the prover node has more chances to get them. */ async startCollectingMissingTxs(blocks) {
         try {
-            const provenBlockNumber = Math.max(await this.getSyncedProvenBlockNum(), this.provenBlockNumberAtStart);
+            // TODO(#15435): If the archiver has lagged behind L1, the reported proven block number may
+            // be much lower than the actual one, and it does not update until the pending chain is
+            // fully synced. This could lead to a ton of tx collection requests for blocks that
+            // are already proven, but the archiver has not yet updated its state. Until this is properly
+            // fixed, it is mitigated by the expiration date of collection requests, which depends on
+            // the slot number of the block.
+            const provenBlockNumber = await this.l2BlockSource.getProvenBlockNumber();
             const unprovenBlocks = blocks.filter((block)=>block.number > provenBlockNumber);
-            const txHashes = unprovenBlocks.flatMap((block)=>block.body.txEffects.map((txEffect)=>txEffect.txHash));
-            const missingTxHashes = await this.txPool.hasTxs(txHashes).then((availability)=>txHashes.filter((_, index)=>!availability[index]));
-            if (missingTxHashes.length > 0) {
-                this.log.verbose(`Requesting ${missingTxHashes.length} missing txs from peers for ${unprovenBlocks.length} unproven mined blocks`, {
-                    missingTxHashes,
-                    unprovenBlockNumbers: unprovenBlocks.map((block)=>block.number)
-                });
-                await this.requestTxsByHash(missingTxHashes, undefined);
+            for (const block of unprovenBlocks){
+                const txHashes = block.body.txEffects.map((txEffect)=>txEffect.txHash);
+                const missingTxHashes = await this.txPool.hasTxs(txHashes).then((availability)=>txHashes.filter((_, index)=>!availability[index]));
+                if (missingTxHashes.length > 0) {
+                    this.log.verbose(`Starting collection of ${missingTxHashes.length} missing txs for unproven mined block ${block.number}`, {
+                        missingTxHashes,
+                        blockNumber: block.number,
+                        blockHash: await block.hash().then((h)=>h.toString())
+                    });
+                    this.txCollection.startCollecting(block, missingTxHashes);
+                }
             }
         } catch (err) {
-            this.log.error(`Error requesting missing txs from unproven blocks`, err, {
-                blocks: blocks.map((block)=>block.number)
-            });
+            this.log.error(`Error while starting collection of missing txs for unproven blocks`, err);
         }
     }
     /**
@@ -593,20 +602,13 @@ import { P2PClientState } from './interface.js';
    * Updates the tx pool after a chain prune.
    * @param latestBlock - The block number the chain was pruned to.
    */ async handlePruneL2Blocks(latestBlock) {
-        // NOTE: temporary fix for alphanet, deleting ALL txs that were in the epoch from the pool #13723
-        // TODO: undo once fixed: #13770
         const txsToDelete = new Map();
         const minedTxs = await this.txPool.getMinedTxHashes();
-        for (const [txHash, blockNumber] of minedTxs){
-            if (blockNumber > latestBlock) {
-                txsToDelete.set(txHash.toString(), txHash);
-            }
-        }
         // Find transactions that reference pruned blocks in their historical header
         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 > latestBlock) {
-                const txHash = await tx.getTxHash();
+                const txHash = tx.getTxHash();
                 txsToDelete.set(txHash.toString(), txHash);
             }
         }
@@ -617,16 +619,14 @@ import { P2PClientState } from './interface.js';
         // 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)
-        // NOTE: given current fix for alphanet, the code below is redundant as all these txs will be deleted.
-        // TODO: bring back once fixed: #13770
-        // const txsToMoveToPending: TxHash[] = [];
-        // for (const [txHash, blockNumber] of minedTxs) {
-        //   if (blockNumber > latestBlock) {
-        //     txsToMoveToPending.push(txHash);
-        //   }
-        // }
-        // this.log.info(`Moving ${txsToMoveToPending.length} mined txs back to pending`);
-        // await this.txPool.markMinedAsPending(txsToMoveToPending);
+        const txsToMoveToPending = [];
+        for (const [txHash, blockNumber] of minedTxs){
+            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
     }
@@ -667,6 +667,9 @@ import { P2PClientState } from './interface.js';
    */ markTxsAsNonEvictable(txHashes) {
         return this.txPool.markTxsAsNonEvictable(txHashes);
     }
+    handleAuthRequestFromPeer(authRequest, peerId) {
+        return this.p2pService.handleAuthRequestFromPeer(authRequest, peerId);
+    }
 }
 _ts_decorate([
     trackSpan('p2pClient.broadcastProposal', async (proposal)=>({

package/dest/config.d.ts

@@ -2,10 +2,11 @@ import { type ConfigMappingsType, SecretValue } from '@aztec/foundation/config';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
 import { type AllowedElement, type ChainConfig } from '@aztec/stdlib/config';
 import { type P2PReqRespConfig } from './services/reqresp/config.js';
+import { type TxCollectionConfig } from './services/tx_collection/config.js';
 /**
  * P2P client configuration values.
  */
-export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
+export interface P2PConfig extends P2PReqRespConfig, ChainConfig, TxCollectionConfig {
     /** A flag dictating whether the P2P subsystem should be enabled. */
     p2pEnabled: boolean;
     /** The frequency in which to check for new L2 blocks. */
@@ -74,6 +75,8 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
     trustedPeers: string[];
     /** A list of private peers. */
     privatePeers: string[];
+    /** A list of preferred peers. */
+    preferredPeers: string[];
     /** 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. */
@@ -86,6 +89,16 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
     seenMessageCacheSize: number;
     /** True to disable the status handshake on peer connected. */
     p2pDisableStatusHandshake?: boolean;
+    /** True to only permit validators to connect */
+    p2pAllowOnlyValidators?: boolean;
+    /** True to disable participating in discovery */
+    p2pDiscoveryDisabled?: boolean;
+    /** Number of auth attempts to allow before peer is banned. Number is inclusive*/
+    p2pMaxFailedAuthAttemptsAllowed: number;
+    /** True to simulate discarding transactions. - For testing purposes only*/
+    dropTransactions: boolean;
+    /** The probability that a transaction is discarded. - For testing purposes only */
+    dropTransactionsProbability: number;
 }
 export declare const DEFAULT_P2P_PORT = 40400;
 export declare const p2pConfigMappings: ConfigMappingsType<P2PConfig>;
@@ -109,6 +122,16 @@ export declare const bootnodeConfigMappings: ConfigMappingsType<Pick<{
     individualRequestTimeoutMs: unknown;
     p2pOptimisticNegotiation: unknown;
     dialTimeoutMs: unknown;
+    txCollectionFastNodesTimeoutBeforeReqRespMs: unknown;
+    txCollectionSlowNodesIntervalMs: unknown;
+    txCollectionSlowReqRespIntervalMs: unknown;
+    txCollectionSlowReqRespTimeoutMs: unknown;
+    txCollectionReconcileIntervalMs: unknown;
+    txCollectionDisableSlowDuringFastRequests: unknown;
+    txCollectionFastNodeIntervalMs: unknown;
+    txCollectionNodeRpcUrls: unknown;
+    txCollectionFastMaxParallelRequestsPerNode: unknown;
+    txCollectionNodeRpcMaxBatchSize: unknown;
     p2pEnabled: unknown;
     blockCheckIntervalMS: unknown;
     blockRequestBatchSize: unknown;
@@ -143,12 +166,18 @@ export declare const bootnodeConfigMappings: ConfigMappingsType<Pick<{
     archivedTxLimit: unknown;
     trustedPeers: unknown;
     privatePeers: unknown;
+    preferredPeers: unknown;
     p2pStoreMapSizeKb: unknown;
     txPublicSetupAllowList: unknown;
     maxTxPoolSize: unknown;
     txPoolOverflowFactor: unknown;
     seenMessageCacheSize: unknown;
     p2pDisableStatusHandshake: unknown;
+    p2pAllowOnlyValidators: unknown;
+    p2pDiscoveryDisabled: unknown;
+    p2pMaxFailedAuthAttemptsAllowed: unknown;
+    dropTransactions: unknown;
+    dropTransactionsProbability: unknown;
 }, "p2pPort" | "p2pBroadcastPort" | "p2pIp" | "listenAddress" | "peerIdPrivateKey" | "peerIdPrivateKeyPath" | "bootstrapNodes" | "l1ChainId" | "dataDirectory" | "dataStoreMapSizeKB">>;
 /**
  * Parses a string to a list of allowed elements.

package/dest/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dest/config.js

@@ -5,6 +5,7 @@ import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { chainConfigMappings } from '@aztec/stdlib/config';
 import { p2pReqRespConfigMappings } from './services/reqresp/config.js';
+import { txCollectionConfigMappings } from './services/tx_collection/config.js';
 export const DEFAULT_P2P_PORT = 40400;
 export const p2pConfigMappings = {
     p2pEnabled: {
@@ -12,6 +13,11 @@ export const p2pConfigMappings = {
         description: 'A flag dictating whether the P2P subsystem should be enabled.',
         ...booleanConfigHelper()
     },
+    p2pDiscoveryDisabled: {
+        env: 'P2P_DISCOVERY_DISABLED',
+        description: 'A flag dictating whether the P2P discovery system should be disabled.',
+        ...booleanConfigHelper(false)
+    },
     blockCheckIntervalMS: {
         env: 'P2P_BLOCK_CHECK_INTERVAL_MS',
         description: 'The frequency in which to check for new L2 blocks.',
@@ -182,6 +188,12 @@ export const p2pConfigMappings = {
         description: 'A list of private peer ENRs that will always be persisted and not be used for discovery. Separated by commas.',
         defaultValue: []
     },
+    preferredPeers: {
+        env: 'P2P_PREFERRED_PEERS',
+        parseEnv: (val)=>val.split(','),
+        description: 'A list of preferred peer ENRs that will always be persisted and not be used for discovery. Separated by commas.',
+        defaultValue: []
+    },
     p2pStoreMapSizeKb: {
         env: 'P2P_STORE_MAP_SIZE_KB',
         parseEnv: (val)=>val ? +val : undefined,
@@ -213,8 +225,29 @@ export const p2pConfigMappings = {
         description: 'True to disable the status handshake on peer connected.',
         ...booleanConfigHelper(false)
     },
+    p2pAllowOnlyValidators: {
+        env: 'P2P_ALLOW_ONLY_VALIDATORS',
+        description: 'True to only permit validators to connect.',
+        ...booleanConfigHelper(false)
+    },
+    p2pMaxFailedAuthAttemptsAllowed: {
+        env: 'P2P_MAX_AUTH_FAILED_ATTEMPTS_ALLOWED',
+        description: 'Number of auth attempts to allow before peer is banned. Number is inclusive',
+        ...numberConfigHelper(3)
+    },
+    dropTransactions: {
+        env: 'P2P_DROP_TX',
+        description: 'True to simulate discarding transactions. - For testing purposes only',
+        ...booleanConfigHelper(false)
+    },
+    dropTransactionsProbability: {
+        env: 'P2P_DROP_TX_CHANCE',
+        description: 'The probability that a transaction is discarded. - For testing purposes only',
+        ...floatConfigHelper(0)
+    },
     ...p2pReqRespConfigMappings,
-    ...chainConfigMappings
+    ...chainConfigMappings,
+    ...txCollectionConfigMappings
 };
 /**
  * Gets the config values for p2p client from environment variables.

package/dest/index.d.ts

@@ -1,3 +1,4 @@
+export { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 export type { PeerId } from '@libp2p/interface';
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';

package/dest/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,YAAY,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC"}

package/dest/index.js

@@ -1,3 +1,4 @@
+export { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
 export * from './enr/index.js';

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

@@ -1,4 +1,4 @@
-import type { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { BlockAttestation, BlockProposal } from '@aztec/stdlib/p2p';
 /**
  * An Attestation Pool contains attestations collected by a validator
  *
@@ -6,6 +6,18 @@ import type { BlockAttestation } from '@aztec/stdlib/p2p';
  * from the validator to produce a block, or to serve to other peers.
  */
 export interface AttestationPool {
+    /**
+     * Adds new block proposal to the pool
+     */
+    addBlockProposal(blockProposal: BlockProposal): Promise<void>;
+    /**
+     * Get block proposal by it's 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.
+     */
+    getBlockProposal(id: string): Promise<BlockProposal | undefined>;
     /**
      * AddAttestations
      *

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

@@ -1 +1 @@
-{"version":3,"file":"attestation_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,eAAe,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;OAIG;IACH,kBAAkB,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;;;OAMG;IACH,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;;;;;OAMG;IACH,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACH,oCAAoC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtF;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAElE;;;;;;;;OAQG;IACH,iCAAiC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAEjG,yCAAyC;IACzC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B"}
+{"version":3,"file":"attestation_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,gBAAgB,CAAC,aAAa,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE9D;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC;IAEjE;;;;OAIG;IACH,eAAe,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjE;;;;OAIG;IACH,kBAAkB,CAAC,YAAY,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;;;OAMG;IACH,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;;;;;OAMG;IACH,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD;;;;;;;OAOG;IACH,oCAAoC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtF;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAElE;;;;;;;;OAQG;IACH,iCAAiC,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;IAEjG,yCAAyC;IACzC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B"}

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":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK7D,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA8NhF"}
+{"version":3,"file":"attestation_pool_test_suite.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/attestation_pool_test_suite.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK7D,wBAAgB,uBAAuB,CAAC,kBAAkB,EAAE,MAAM,eAAe,QA8WhF"}