@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/services/reqresp/batch-tx-requester/config.ts

@@ -0,0 +1,40 @@
+import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
+
+export const DEFAULT_BATCH_TX_REQUESTER_SMART_PARALLEL_WORKER_COUNT = 10;
+export const DEFAULT_BATCH_TX_REQUESTER_DUMB_PARALLEL_WORKER_COUNT = 10;
+export const DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE = 8;
+export const DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD = 2;
+
+export interface BatchTxRequesterConfig {
+  /** Max concurrent requests to smart peers. */
+  batchTxRequesterSmartParallelWorkerCount: number;
+  /** Max concurrent requests to dumb peers. */
+  batchTxRequesterDumbParallelWorkerCount: number;
+  /** Max transactions per request / chunk size. */
+  batchTxRequesterTxBatchSize: number;
+  /** Failures before a peer is considered bad (see > threshold logic). */
+  batchTxRequesterBadPeerThreshold: number;
+}
+
+export const batchTxRequesterConfigMappings: ConfigMappingsType<BatchTxRequesterConfig> = {
+  batchTxRequesterSmartParallelWorkerCount: {
+    env: 'P2P_BATCH_TX_REQUESTER_SMART_PARALLEL_WORKER_COUNT',
+    description: 'Max concurrent requests to smart peers for batch tx requester.',
+    ...numberConfigHelper(DEFAULT_BATCH_TX_REQUESTER_SMART_PARALLEL_WORKER_COUNT),
+  },
+  batchTxRequesterDumbParallelWorkerCount: {
+    env: 'P2P_BATCH_TX_REQUESTER_DUMB_PARALLEL_WORKER_COUNT',
+    description: 'Max concurrent requests to dumb peers for batch tx requester.',
+    ...numberConfigHelper(DEFAULT_BATCH_TX_REQUESTER_DUMB_PARALLEL_WORKER_COUNT),
+  },
+  batchTxRequesterTxBatchSize: {
+    env: 'P2P_BATCH_TX_REQUESTER_TX_BATCH_SIZE',
+    description: 'Max transactions per request / chunk size for batch tx requester.',
+    ...numberConfigHelper(DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE),
+  },
+  batchTxRequesterBadPeerThreshold: {
+    env: 'P2P_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD',
+    description: 'Failures before a peer is considered bad (see > threshold logic).',
+    ...numberConfigHelper(DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD),
+  },
+};

package/src/services/reqresp/batch-tx-requester/interface.ts

@@ -0,0 +1,57 @@
+import type { ISemaphore } from '@aztec/foundation/queue';
+import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+import type { Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+import type { ConnectionSampler } from '../connection-sampler/connection_sampler.js';
+import type { ReqRespInterface } from '../interface.js';
+import type { MissingTxMetadata } from './missing_txs.js';
+import type { IPeerCollection } from './peer_collection.js';
+import type { BatchRequestTxValidatorConfig, IBatchRequestTxValidator } from './tx_validator.js';
+
+export interface IPeerPenalizer {
+  penalizePeer(peerId: PeerId, penalty: PeerErrorSeverity): void;
+}
+
+export interface ITxMetadataCollection {
+  size: number;
+  values(): IterableIterator<MissingTxMetadata>;
+  getMissingTxHashes(): Set<string>;
+  getTxsToRequestFromThePeer(peer: PeerId): TxHash[];
+  markRequested(txHash: TxHash): void;
+  markInFlightBySmartPeer(txHash: TxHash): void;
+  markNotInFlightBySmartPeer(txHash: TxHash): void;
+  alreadyFetched(txHash: TxHash): boolean;
+  // Returns true if tx was marked as fetched, false if it was already marked as fetched
+  markFetched(peerId: PeerId, tx: Tx): boolean;
+  markPeerHas(peerId: PeerId, txHashes: TxHash[]): void;
+  getFetchedTxs(): Tx[];
+}
+
+/**
+ * Interface for BatchTxRequester dependencies that can be injected from upstream
+ */
+export interface BatchTxRequesterLibP2PService {
+  /** ReqResp interface for sending requests to peers */
+  reqResp: Pick<ReqRespInterface, 'sendBatchRequest' | 'sendRequestToPeer'>;
+  /** Connection sampler for getting peer lists */
+  connectionSampler: Pick<ConnectionSampler, 'getPeerListSortedByConnectionCountAsc'>;
+  /** Configuration needed for transaction validation */
+  txValidatorConfig: BatchRequestTxValidatorConfig;
+  /** Peer scoring for penalizing peers */
+  peerScoring: IPeerPenalizer;
+}
+
+export interface BatchTxRequesterOptions {
+  smartParallelWorkerCount?: number;
+  dumbParallelWorkerCount?: number;
+  txBatchSize?: number;
+  badPeerThreshold?: number;
+  //Injectable for testing purposes
+  semaphore?: ISemaphore;
+  peerCollection?: IPeerCollection;
+  abortSignal?: AbortSignal;
+  /** Optional tx validator for testing - if not provided, one is created from p2pService.txValidatorConfig */
+  txValidator?: IBatchRequestTxValidator;
+}

package/src/services/reqresp/batch-tx-requester/missing_txs.ts

@@ -0,0 +1,209 @@
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+import { DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE } from './config.js';
+import type { ITxMetadataCollection } from './interface.js';
+
+export class MissingTxMetadata {
+  constructor(
+    public readonly txHash: TxHash,
+    public fetched = false,
+    public requestedCount = 0,
+    public inFlightCount = 0,
+    public tx: Tx | undefined = undefined,
+    public readonly peers = new Set<string>(),
+  ) {}
+
+  public markAsRequested() {
+    this.requestedCount++;
+  }
+
+  public markInFlight() {
+    this.inFlightCount++;
+  }
+
+  public markNotInFlight() {
+    this.inFlightCount = Math.max(--this.inFlightCount, 0);
+  }
+
+  public isInFlight(): boolean {
+    return this.inFlightCount > 0;
+  }
+
+  //Returns true if this is the first time we mark it as fetched
+  public markAsFetched(peerId: PeerId, tx: Tx): boolean {
+    if (this.fetched) {
+      return false;
+    }
+
+    this.fetched = true;
+    this.tx = tx;
+
+    this.peers.add(peerId.toString());
+
+    return true;
+  }
+
+  public toString() {
+    return this.txHash.toString();
+  }
+}
+
+/*
+ * Single source or truth for transactions we are fetching
+ * This could be better optimized but given expected count of missing txs (N < 100)
+ * At the moment there is no need for it. And benefit is that we have everything in single store
+ * */
+export class MissingTxMetadataCollection extends Map<string, MissingTxMetadata> implements ITxMetadataCollection {
+  constructor(
+    entries?: readonly (readonly [string, MissingTxMetadata])[] | null,
+    private readonly txBatchSize: number = DEFAULT_BATCH_TX_REQUESTER_TX_BATCH_SIZE,
+  ) {
+    super(entries);
+  }
+  public getSortedByRequestedCountAsc(txs: string[]): MissingTxMetadata[] {
+    return Array.from(this.values().filter(txMeta => txs.includes(txMeta.txHash.toString()))).sort(
+      (a, b) => a.requestedCount - b.requestedCount,
+    );
+  }
+
+  public getPrioritizingNotInFlightAndLowerRequestCount(txs: string[]): MissingTxMetadata[] {
+    const filtered = Array.from(this.values()).filter(txMeta => txs.includes(txMeta.txHash.toString()));
+
+    const [notInFlight, inFlight] = filtered.reduce<[MissingTxMetadata[], MissingTxMetadata[]]>(
+      (buckets, tx) => {
+        tx.isInFlight() ? buckets[1].push(tx) : buckets[0].push(tx);
+        return buckets;
+      },
+      [[], []],
+    );
+
+    notInFlight.sort((a, b) => a.requestedCount - b.requestedCount);
+    inFlight.sort((a, b) => a.inFlightCount - b.inFlightCount);
+
+    return [...notInFlight, ...inFlight];
+  }
+
+  public getFetchedTxHashes(): Set<string> {
+    return new Set(
+      this.values()
+        .filter(t => t.fetched)
+        .map(t => t.txHash.toString()),
+    );
+  }
+
+  public getMissingTxHashes(): Set<string> {
+    return new Set(
+      this.values()
+        .filter(t => !t.fetched)
+        .map(t => t.txHash.toString()),
+    );
+  }
+
+  public getInFlightTxHashes(): Set<string> {
+    return new Set(
+      this.values()
+        .filter(t => t.isInFlight())
+        .map(t => t.txHash.toString()),
+    );
+  }
+
+  public getFetchedTxs(): Tx[] {
+    return Array.from(
+      this.values()
+        .map(t => t.tx)
+        .filter(t => !!t),
+    );
+  }
+
+  public getTxsPeerHas(peer: PeerId): Set<string> {
+    const peerIdStr = peer.toString();
+    const txsPeerHas = new Set<string>();
+
+    this.values().forEach(txMeta => {
+      if (txMeta.peers.has(peerIdStr)) {
+        txsPeerHas.add(txMeta.txHash.toString());
+      }
+    });
+
+    return txsPeerHas;
+  }
+
+  public getTxsToRequestFromThePeer(peer: PeerId): TxHash[] {
+    const txsPeerHas = this.getTxsPeerHas(peer);
+    const fetchedTxs = this.getFetchedTxHashes();
+
+    const txsToRequest = txsPeerHas.difference(fetchedTxs);
+
+    if (txsToRequest.size >= this.txBatchSize) {
+      return this.getPrioritizingNotInFlightAndLowerRequestCount(Array.from(txsToRequest))
+        .map(t => t.txHash)
+        .slice(0, this.txBatchSize);
+    }
+
+    // Otherwise fill the txs to request till txBatchSize with random txs we are missing
+    // Who knows, maybe we get lucky and peer received these txs in the meantime
+
+    const countToFill = this.txBatchSize - txsToRequest.size;
+    const txsToFill = this.getPrioritizingNotInFlightAndLowerRequestCount(
+      Array.from(this.getMissingTxHashes().difference(txsToRequest)),
+    )
+      .slice(0, countToFill)
+      .map(t => t.txHash);
+
+    return [...Array.from(txsToRequest).map(t => TxHash.fromString(t)), ...txsToFill];
+  }
+
+  public markRequested(txHash: TxHash) {
+    this.get(txHash.toString())?.markAsRequested();
+  }
+
+  /*
+   * This should be called only when requesting tx from smart peer
+   * Because the smart peer should return this tx, whereas
+   * "dumb" peer might return it, or might not - we don't know
+   * */
+  public markInFlightBySmartPeer(txHash: TxHash) {
+    this.get(txHash.toString())?.markInFlight();
+  }
+
+  /*
+   * This should be called only when requesting tx from smart peer
+   * Because the smart peer should return this tx, whereas
+   * "dumb" peer might return it, or might not - we don't know*/
+  public markNotInFlightBySmartPeer(txHash: TxHash) {
+    this.get(txHash.toString())?.markNotInFlight();
+  }
+
+  public alreadyFetched(txHash: TxHash): boolean {
+    return this.get(txHash.toString())?.fetched ?? false;
+  }
+
+  public markFetched(peerId: PeerId, tx: Tx): boolean {
+    const txHashStr = tx.txHash.toString();
+    const txMeta = this.get(txHashStr);
+    if (!txMeta) {
+      //TODO: what to do about peer which sent txs we didn't request?
+      // 1. don't request from it in the scope of this batch request
+      // 2. ban it immediately?
+      // 3. track it and ban it?
+      //
+      return false;
+    }
+
+    return txMeta.markAsFetched(peerId, tx);
+  }
+
+  public markPeerHas(peerId: PeerId, txHash: TxHash[]) {
+    const peerIdStr = peerId.toString();
+    txHash
+      .map(t => t.toString())
+      .forEach(txh => {
+        const txMeta = this.get(txh);
+        if (txMeta) {
+          txMeta.peers.add(peerIdStr);
+        }
+      });
+  }
+}

package/src/services/reqresp/batch-tx-requester/peer_collection.ts

@@ -0,0 +1,205 @@
+import type { DateProvider } from '@aztec/foundation/timer';
+import type { PeerErrorSeverity } from '@aztec/stdlib/p2p';
+
+import type { PeerId } from '@libp2p/interface';
+
+import { DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD } from './config.js';
+import type { IPeerPenalizer } from './interface.js';
+
+export const RATE_LIMIT_EXCEEDED_PEER_CACHE_TTL = 1000; // 1s
+
+export interface IPeerCollection {
+  getAllPeers(): Set<string>;
+  getSmartPeers(): Set<string>;
+  markPeerSmart(peerId: PeerId): void;
+  getSmartPeersToQuery(): Array<string>;
+  getDumbPeersToQuery(): Array<string>;
+  thereAreSomeDumbRatelimitExceededPeers(): boolean;
+  penalisePeer(peerId: PeerId, severity: PeerErrorSeverity): void;
+  unMarkPeerAsBad(peerId: PeerId): void;
+  getBadPeers(): Set<string>;
+  markPeerInFlight(peerId: PeerId): void;
+  unMarkPeerInFlight(peerId: PeerId): void;
+  markPeerRateLimitExceeded(peerId: PeerId): void;
+  getRateLimitExceededPeers(): Set<string>;
+  getPeerRateLimitDelayMs(peerId: PeerId): number | undefined;
+  getNextDumbPeerAvailabilityDelayMs(): number | undefined;
+  getNextSmartPeerAvailabilityDelayMs(): number | undefined;
+}
+
+export class PeerCollection implements IPeerCollection {
+  private readonly peers;
+
+  private readonly smartPeers = new Set<string>();
+  private readonly inFlightPeers = new Set<string>();
+  private readonly rateLimitExceededPeers = new Map<string, number>();
+  private readonly peerPenaltyCounters = new Map<string, number>();
+  private readonly badPeers = new Set<string>();
+
+  constructor(
+    initialPeers: PeerId[],
+    private readonly pinnedPeerId: PeerId | undefined,
+    private readonly dateProvider: DateProvider,
+    private readonly badPeerThreshold: number = DEFAULT_BATCH_TX_REQUESTER_BAD_PEER_THRESHOLD,
+    private readonly peerPenalizer?: IPeerPenalizer,
+  ) {
+    this.peers = new Set(initialPeers.map(peer => peer.toString()));
+
+    // Pinned peer is treaded specially, always mark it as in-flight
+    // and never return it as part of smart/dumb peers
+    if (this.pinnedPeerId) {
+      const peerIdStr = this.pinnedPeerId.toString();
+      this.inFlightPeers.add(peerIdStr);
+      this.peers.delete(peerIdStr);
+    }
+  }
+
+  public getAllPeers(): Set<string> {
+    return this.peers;
+  }
+
+  public getSmartPeers(): Set<string> {
+    return this.smartPeers;
+  }
+
+  public markPeerSmart(peerId: PeerId): void {
+    this.smartPeers.add(peerId.toString());
+  }
+
+  public getSmartPeersToQuery(): Array<string> {
+    return Array.from(
+      this.smartPeers.difference(this.getBadPeers().union(this.inFlightPeers).union(this.getRateLimitExceededPeers())),
+    );
+  }
+
+  public getDumbPeersToQuery(): Array<string> {
+    return Array.from(
+      this.peers.difference(
+        this.smartPeers.union(this.getBadPeers()).union(this.inFlightPeers).union(this.getRateLimitExceededPeers()),
+      ),
+    );
+  }
+
+  public thereAreSomeDumbRatelimitExceededPeers(): boolean {
+    return (
+      this.getRateLimitExceededPeers().difference(this.smartPeers.union(this.badPeers).union(this.inFlightPeers)).size >
+      0
+    );
+  }
+
+  public markPeerInFlight(peerId: PeerId) {
+    this.inFlightPeers.add(peerId.toString());
+  }
+
+  public unMarkPeerInFlight(peerId: PeerId) {
+    // Never unmark the pinned peer as in-flight
+    if (this.pinnedPeerId && this.pinnedPeerId.toString() === peerId.toString()) {
+      return;
+    }
+    this.inFlightPeers.delete(peerId.toString());
+  }
+
+  public markPeerRateLimitExceeded(peerId: PeerId) {
+    const ttl = this.dateProvider.now() + RATE_LIMIT_EXCEEDED_PEER_CACHE_TTL;
+    this.rateLimitExceededPeers.set(peerId.toString(), ttl);
+  }
+
+  public getRateLimitExceededPeers(): Set<string> {
+    const now = this.dateProvider.now();
+    const rateLimitedPeers = new Set<string>();
+
+    for (const [peerId, expirationTime] of this.rateLimitExceededPeers) {
+      if (expirationTime <= now) {
+        this.rateLimitExceededPeers.delete(peerId);
+      } else {
+        rateLimitedPeers.add(peerId);
+      }
+    }
+
+    return rateLimitedPeers;
+  }
+
+  public penalisePeer(peerId: PeerId, severity: PeerErrorSeverity): void {
+    const key = peerId.toString();
+    const newPenaltyCount = (this.peerPenaltyCounters.get(key) ?? 0) + 1;
+    this.peerPenaltyCounters.set(key, newPenaltyCount);
+    this.peerPenalizer?.penalizePeer(peerId, severity);
+    if (newPenaltyCount > this.badPeerThreshold) {
+      this.badPeers.add(key);
+    }
+  }
+
+  public unMarkPeerAsBad(peerId: PeerId) {
+    const key = peerId.toString();
+    this.badPeers.delete(key);
+    this.peerPenaltyCounters.delete(key);
+  }
+
+  public getBadPeers(): Set<string> {
+    return new Set(this.badPeers);
+  }
+
+  public getPeerRateLimitDelayMs(peerId: PeerId): number | undefined {
+    const key = peerId.toString();
+    const expiry = this.rateLimitExceededPeers.get(key);
+    const peerIsNotRateLimited = expiry === undefined;
+    if (peerIsNotRateLimited) {
+      return undefined;
+    }
+
+    const now = this.dateProvider.now();
+    const rateLimitHasExpired = expiry <= now;
+    if (rateLimitHasExpired) {
+      this.rateLimitExceededPeers.delete(key);
+      return undefined;
+    }
+    return expiry - now;
+  }
+
+  public getNextDumbPeerAvailabilityDelayMs(): number | undefined {
+    // Note: this _is_ suboptimal
+    // (we could've tracked rate limits ) per dumb/smart peers - different collections
+    // but everything is in memory and small scale so this, wile suboptimal is not slow
+    return this.getNextRateLimitDelayMs(
+      peerIdStr =>
+        !this.smartPeers.has(peerIdStr) &&
+        !this.getBadPeers().has(peerIdStr) &&
+        !this.inFlightPeers.has(peerIdStr) &&
+        this.peers.has(peerIdStr),
+    );
+  }
+
+  public getNextSmartPeerAvailabilityDelayMs(): number | undefined {
+    return this.getNextRateLimitDelayMs(
+      peerIdStr =>
+        this.smartPeers.has(peerIdStr) && !this.getBadPeers().has(peerIdStr) && !this.inFlightPeers.has(peerIdStr),
+    );
+  }
+
+  private getNextRateLimitDelayMs(filter: (peerIdStr: string) => boolean): number | undefined {
+    const now = this.dateProvider.now();
+    let minExpiry: number | undefined;
+
+    for (const [peerIdStr, expiry] of this.rateLimitExceededPeers) {
+      const rateLimitHasExpired = expiry <= now;
+      if (rateLimitHasExpired) {
+        this.rateLimitExceededPeers.delete(peerIdStr);
+        continue;
+      }
+
+      const peerDoesNotMatchFilter = !filter(peerIdStr);
+      if (peerDoesNotMatchFilter) {
+        continue;
+      }
+
+      minExpiry = minExpiry === undefined ? expiry : Math.min(minExpiry, expiry);
+    }
+
+    const noRateLimitedPeersMatchFilter = minExpiry === undefined;
+    if (noRateLimitedPeersMatchFilter) {
+      return undefined;
+    }
+
+    return minExpiry! - now;
+  }
+}

package/src/services/reqresp/batch-tx-requester/tx_validator.ts

@@ -0,0 +1,37 @@
+import type { ClientProtocolCircuitVerifier } from '@aztec/stdlib/interfaces/server';
+import { Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+
+import { createTxReqRespValidator } from '../../../msg_validators/tx_validator/factory.js';
+
+export interface BatchRequestTxValidatorConfig {
+  l1ChainId: number;
+  rollupVersion: number;
+  proofVerifier: ClientProtocolCircuitVerifier;
+}
+
+export interface IBatchRequestTxValidator {
+  validateRequestedTx(tx: Tx): Promise<TxValidationResult>;
+  validateRequestedTxs(txs: Tx[]): Promise<TxValidationResult[]>;
+}
+
+export class BatchRequestTxValidator implements IBatchRequestTxValidator {
+  readonly txValidator: TxValidator;
+  constructor(private readonly config: BatchRequestTxValidatorConfig) {
+    this.txValidator = BatchRequestTxValidator.createRequestedTxValidator(this.config);
+  }
+
+  public async validateRequestedTx(tx: Tx): Promise<TxValidationResult> {
+    return await this.txValidator.validateTx(tx);
+  }
+
+  public async validateRequestedTxs(txs: Tx[]): Promise<TxValidationResult[]> {
+    return await Promise.all(txs.map(tx => this.validateRequestedTx(tx)));
+  }
+
+  static createRequestedTxValidator(config: BatchRequestTxValidatorConfig): TxValidator {
+    return createTxReqRespValidator(config.proofVerifier, {
+      l1ChainId: config.l1ChainId,
+      rollupVersion: config.rollupVersion,
+    });
+  }
+}

package/src/services/reqresp/config.ts

@@ -1,24 +1,30 @@
-import { type ConfigMapping, numberConfigHelper } from '@aztec/foundation/config';
+import { type ConfigMapping, booleanConfigHelper, numberConfigHelper } from '@aztec/foundation/config';
 
-export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 2000;
-export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 4000;
+export const DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS = 10_000;
+export const DEFAULT_OVERALL_REQUEST_TIMEOUT_MS = 10_000; // Not currently used
+export const DEFAULT_REQRESP_DIAL_TIMEOUT_MS = 5_000;
+export const DEFAULT_OPTIMISTIC_NEGOTIATION = false;
 
 // For use in tests.
 export const DEFAULT_P2P_REQRESP_CONFIG: P2PReqRespConfig = {
   overallRequestTimeoutMs: DEFAULT_OVERALL_REQUEST_TIMEOUT_MS,
   individualRequestTimeoutMs: DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS,
+  dialTimeoutMs: DEFAULT_REQRESP_DIAL_TIMEOUT_MS,
+  p2pOptimisticNegotiation: DEFAULT_OPTIMISTIC_NEGOTIATION,
 };
 
 export interface P2PReqRespConfig {
-  /**
-   * The overall timeout for a request response operation.
-   */
+  /** The overall timeout for a request response operation. */
   overallRequestTimeoutMs: number;
 
-  /**
-   * The timeout for an individual request response peer interaction.
-   */
+  /** The timeout for an individual request response peer interaction. */
   individualRequestTimeoutMs: number;
+
+  /** Whether to use optimistic protocol negotiation when dialing to another peer (opposite of `negotiateFully`). */
+  p2pOptimisticNegotiation: boolean;
+
+  /** How long to wait for the dial protocol to establish a connection */
+  dialTimeoutMs: number;
 }
 
 export const p2pReqRespConfigMappings: Record<keyof P2PReqRespConfig, ConfigMapping> = {
@@ -32,4 +38,15 @@ export const p2pReqRespConfigMappings: Record<keyof P2PReqRespConfig, ConfigMapp
     description: 'The timeout for an individual request response peer interaction.',
     ...numberConfigHelper(DEFAULT_INDIVIDUAL_REQUEST_TIMEOUT_MS),
   },
+  dialTimeoutMs: {
+    env: 'P2P_REQRESP_DIAL_TIMEOUT_MS',
+    description: 'How long to wait for the dial protocol to establish a connection',
+    ...numberConfigHelper(DEFAULT_REQRESP_DIAL_TIMEOUT_MS),
+  },
+  p2pOptimisticNegotiation: {
+    env: 'P2P_REQRESP_OPTIMISTIC_NEGOTIATION',
+    description:
+      'Whether to use optimistic protocol negotiation when dialing to another peer (opposite of `negotiateFully`).',
+    ...booleanConfigHelper(DEFAULT_OPTIMISTIC_NEGOTIATION),
+  },
 };