@aztec/p2p 0.0.1-fake-c83136db25 → 0.0.2-commit.217f559981

package/src/client/factory.ts

@@ -4,31 +4,39 @@ import { DateProvider } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
 import { AztecLMDBStoreV2, createStore } from '@aztec/kv-store/lmdb-v2';
-import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { BlockHash, L2BlockSource } from '@aztec/stdlib/block';
 import type { ChainConfig } from '@aztec/stdlib/config';
 import type { ContractDataSource } from '@aztec/stdlib/contract';
-import type { ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
+import type { AztecNode, ClientProtocolCircuitVerifier, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
 import { P2PClientType } from '@aztec/stdlib/p2p';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { P2PClient } from '../client/p2p_client.js';
 import type { P2PConfig } from '../config.js';
-import type { AttestationPool } from '../mem_pools/attestation_pool/attestation_pool.js';
-import { KvAttestationPool } from '../mem_pools/attestation_pool/kv_attestation_pool.js';
+import { AttestationPool, type AttestationPoolApi } from '../mem_pools/attestation_pool/attestation_pool.js';
 import type { MemPools } from '../mem_pools/interface.js';
-import { AztecKVTxPool, type TxPool } from '../mem_pools/tx_pool/index.js';
+import type { TxPoolV2 } from '../mem_pools/tx_pool_v2/interfaces.js';
+import type { TxMetaData } from '../mem_pools/tx_pool_v2/tx_metadata.js';
+import { AztecKVTxPoolV2 } from '../mem_pools/tx_pool_v2/tx_pool_v2.js';
+import { AggregateTxValidator } from '../msg_validators/tx_validator/aggregate_tx_validator.js';
+import { BlockHeaderTxValidator } from '../msg_validators/tx_validator/block_header_validator.js';
+import { DoubleSpendTxValidator } from '../msg_validators/tx_validator/double_spend_validator.js';
 import { DummyP2PService } from '../services/dummy_service.js';
 import { LibP2PService } from '../services/index.js';
+import { createFileStoreTxSources } from '../services/tx_collection/file_store_tx_source.js';
 import { TxCollection } from '../services/tx_collection/tx_collection.js';
-import { type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
+import { NodeRpcTxSource, type TxSource, createNodeRpcTxSources } from '../services/tx_collection/tx_source.js';
+import { TxFileStore } from '../services/tx_file_store/tx_file_store.js';
 import { configureP2PClientAddresses, createLibP2PPeerIdFromPrivateKey, getPeerIdPrivateKey } from '../util.js';
 
 export type P2PClientDeps<T extends P2PClientType> = {
-  txPool?: TxPool;
+  txPool?: TxPoolV2;
   store?: AztecAsyncKVStore;
-  attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+  attestationPool?: AttestationPoolApi;
   logger?: Logger;
   txCollectionNodeSources?: TxSource[];
+  rpcTxProviders?: AztecNode[];
   p2pServiceFactory?: (...args: Parameters<(typeof LibP2PService)['new']>) => Promise<LibP2PService<T>>;
 };
 
@@ -62,30 +70,65 @@ export async function createP2PClient<T extends P2PClientType>(
     );
   }
 
-  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, createLogger('p2p:lmdb-v2')));
-  const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, createLogger('p2p-archive:lmdb-v2'));
-  const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, createLogger('p2p-peer:lmdb-v2'));
-  const attestationStore = await createStore(
-    P2P_ATTESTATION_STORE_NAME,
-    1,
-    config,
-    createLogger('p2p-attestation:lmdb-v2'),
-  );
+  const bindings = logger.getBindings();
+  const store = deps.store ?? (await createStore(P2P_STORE_NAME, 2, config, bindings));
+  const archive = await createStore(P2P_ARCHIVE_STORE_NAME, 1, config, bindings);
+  const peerStore = await createStore(P2P_PEER_STORE_NAME, 1, config, bindings);
+  const attestationStore = await createStore(P2P_ATTESTATION_STORE_NAME, 1, config, bindings);
   const l1Constants = await archiver.getL1Constants();
 
-  const mempools: MemPools<T> = {
-    txPool:
-      deps.txPool ??
-      new AztecKVTxPool(store, archive, worldStateSynchronizer, telemetry, {
-        maxTxPoolSize: config.maxTxPoolSize,
+  const rollupAddress = inputConfig.l1Contracts.rollupAddress.toString().toLowerCase().replace(/^0x/, '');
+  const txFileStoreBasePath = `aztec-${inputConfig.l1ChainId}-${inputConfig.rollupVersion}-0x${rollupAddress}`;
+
+  /** Validator factory for pool re-validation (double-spend + block header only). */
+  const createPoolTxValidator = async () => {
+    await worldStateSynchronizer.syncImmediate();
+    return new AggregateTxValidator<TxMetaData>(
+      new DoubleSpendTxValidator<TxMetaData>(
+        {
+          nullifiersExist: async (nullifiers: Buffer[]) => {
+            const merkleTree = worldStateSynchronizer.getCommitted();
+            const indices = await merkleTree.findLeafIndices(MerkleTreeId.NULLIFIER_TREE, nullifiers);
+            return indices.map(index => index !== undefined);
+          },
+        },
+        bindings,
+      ),
+      new BlockHeaderTxValidator<TxMetaData>(
+        {
+          getArchiveIndices: (archives: BlockHash[]) => {
+            const merkleTree = worldStateSynchronizer.getCommitted();
+            return merkleTree.findLeafIndices(MerkleTreeId.ARCHIVE, archives);
+          },
+        },
+        bindings,
+      ),
+    );
+  };
+
+  const txPool =
+    deps.txPool ??
+    new AztecKVTxPoolV2(
+      store,
+      archive,
+      {
+        l2BlockSource: archiver,
+        worldStateSynchronizer,
+        createTxValidator: createPoolTxValidator,
+      },
+      telemetry,
+      {
+        maxPendingTxCount: config.maxPendingTxCount,
         archivedTxLimit: config.archivedTxLimit,
-      }),
-    attestationPool:
-      clientType === P2PClientType.Full
-        ? ((deps.attestationPool ?? new KvAttestationPool(attestationStore, telemetry)) as T extends P2PClientType.Full
-            ? AttestationPool
-            : undefined)
-        : undefined,
+        minTxPoolAgeMs: config.minTxPoolAgeMs,
+        dropTransactionsProbability: config.dropTransactionsProbability,
+      },
+      dateProvider,
+    );
+
+  const mempools: MemPools = {
+    txPool,
+    attestationPool: deps.attestationPool ?? new AttestationPool(attestationStore, telemetry),
   };
 
   const p2pService = await createP2PService<T>(
@@ -106,6 +149,7 @@ export async function createP2PClient<T extends P2PClientType>(
 
   const nodeSources = [
     ...createNodeRpcTxSources(config.txCollectionNodeRpcUrls, config),
+    ...(deps.rpcTxProviders ?? []).map((node, i) => new NodeRpcTxSource(node, `node-rpc-provider-${i}`)),
     ...(deps.txCollectionNodeSources ?? []),
   ];
   if (nodeSources.length > 0) {
@@ -114,17 +158,38 @@ export async function createP2PClient<T extends P2PClientType>(
     });
   }
 
+  const fileStoreSources = await createFileStoreTxSources(
+    config.txCollectionFileStoreUrls,
+    txFileStoreBasePath,
+    logger.createChild('file-store-tx-source'),
+    telemetry,
+  );
+  if (fileStoreSources.length > 0) {
+    logger.info(`Using ${fileStoreSources.length} file store sources for tx collection.`, {
+      stores: fileStoreSources.map(s => s.getInfo()),
+    });
+  }
+
   const txCollection = new TxCollection(
-    p2pService,
+    p2pService.getBatchTxRequesterService(),
     nodeSources,
     l1Constants,
     mempools.txPool,
     config,
+    fileStoreSources,
     dateProvider,
     telemetry,
     logger.createChild('tx-collection'),
   );
 
+  const txFileStore = await TxFileStore.create(
+    mempools.txPool,
+    config,
+    txFileStoreBasePath,
+    logger.createChild('tx-file-store'),
+    telemetry,
+  );
+
   return new P2PClient(
     clientType,
     store,
@@ -132,6 +197,8 @@ export async function createP2PClient<T extends P2PClientType>(
     mempools,
     p2pService,
     txCollection,
+    txFileStore,
+    epochCache,
     config,
     dateProvider,
     telemetry,
@@ -147,7 +214,7 @@ async function createP2PService<T extends P2PClientType>(
   epochCache: EpochCacheInterface,
   store: AztecAsyncKVStore,
   peerStore: AztecLMDBStoreV2,
-  mempools: MemPools<T>,
+  mempools: MemPools,
   p2pServiceFactory: P2PClientDeps<T>['p2pServiceFactory'],
   packageVersion: string,
   logger: Logger,

package/src/client/interface.ts

@@ -1,7 +1,14 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
 import type { EthAddress, L2BlockId } from '@aztec/stdlib/block';
-import type { P2PApiFull } from '@aztec/stdlib/interfaces/server';
-import type { BlockProposal, P2PClientType } from '@aztec/stdlib/p2p';
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
+import type { ITxProvider, P2PApiFull } from '@aztec/stdlib/interfaces/server';
+import type {
+  BlockProposal,
+  CheckpointAttestation,
+  CheckpointProposal,
+  P2PClientType,
+  TopicType,
+} from '@aztec/stdlib/p2p';
+import type { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
 
 import type { PeerId } from '@libp2p/interface';
 import type { ENR } from '@nethermindeth/enr';
@@ -13,7 +20,12 @@ import type {
   ReqRespSubProtocolHandler,
   ReqRespSubProtocolValidators,
 } from '../services/reqresp/interface.js';
-import type { P2PBlockReceivedCallback } from '../services/service.js';
+import type {
+  DuplicateAttestationInfo,
+  DuplicateProposalInfo,
+  P2PBlockReceivedCallback,
+  P2PCheckpointReceivedCallback,
+} from '../services/service.js';
 
 /**
  * Enum defining the possible states of the p2p client.
@@ -50,6 +62,16 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
    */
   broadcastProposal(proposal: BlockProposal): Promise<void>;
 
+  /**
+   * Broadcasts a checkpoint proposal (last block in a checkpoint) to other peers.
+   *
+   * @param proposal - the checkpoint proposal
+   */
+  broadcastCheckpointProposal(proposal: CheckpointProposal): Promise<void>;
+
+  /** Broadcasts checkpoint attestations to other peers. */
+  broadcastCheckpointAttestations(attestations: CheckpointAttestation[]): Promise<void>;
+
   /**
    * Registers a callback from the validator client that determines how to behave when
    * foreign block proposals are received
@@ -61,12 +83,29 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   registerBlockProposalHandler(callback: P2PBlockReceivedCallback): void;
 
   /**
-   * Request a list of transactions from another peer by their tx hashes.
-   * @param txHashes - Hashes of the txs to query.
-   * @param pinnedPeerId - An optional peer id that will be used to request the tx from (in addition to other random peers).
-   * @returns A list of transactions or undefined if the transactions are not found.
+   * Registers a callback from the validator client that determines how to behave when
+   * foreign checkpoint proposals are received
+   *
+   * @param handler - A function taking a received checkpoint proposal and producing attestations
+   */
+  registerCheckpointProposalHandler(callback: P2PCheckpointReceivedCallback): void;
+
+  /**
+   * Registers a callback invoked when a duplicate proposal is detected (equivocation).
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   *
+   * @param callback - Function called with info about the duplicate proposal
    */
-  requestTxsByHash(txHashes: TxHash[], pinnedPeerId: PeerId): Promise<Tx[]>;
+  registerDuplicateProposalCallback(callback: (info: DuplicateProposalInfo) => void): void;
+
+  /**
+   * Registers a callback invoked when a duplicate attestation is detected (equivocation).
+   * A validator signing attestations for different proposals at the same slot.
+   * The callback is triggered on the first duplicate (when count goes from 1 to 2).
+   *
+   * @param callback - Function called with info about the duplicate attestation
+   */
+  registerDuplicateAttestationCallback(callback: (info: DuplicateAttestationInfo) => void): void;
 
   /**
    * Verifies the 'tx' and, if valid, adds it to local tx pool and forwards it to other peers.
@@ -75,18 +114,10 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   sendTx(tx: Tx): Promise<void>;
 
   /**
-   * Adds transactions to the pool. Does not send to peers or validate the tx.
-   * @param txs - The transactions.
-   * @returns The number of txs added to the pool. Note if the transaction already exists, it will not be added again.
-   **/
-  addTxsToPool(txs: Tx[]): Promise<number>;
-
-  /**
-   * Deletes 'txs' from the pool, given hashes.
-   * NOT used if we use sendTx as reconcileTxPool will handle this.
-   * @param txHashes - Hashes to check.
+   * Handles failed transaction execution by removing txs from the pool.
+   * @param txHashes - Hashes of the transactions that failed execution.
    **/
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
+  handleFailedExecution(txHashes: TxHash[]): Promise<void>;
 
   /**
    * Returns a transaction in the transaction pool by its hash.
@@ -134,14 +165,28 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   /** Returns an iterator over pending txs on the mempool. */
   iteratePendingTxs(): AsyncIterableIterator<Tx>;
 
+  /** Returns an iterator over pending txs that have been in the pool long enough to be eligible for block building. */
+  iterateEligiblePendingTxs(): AsyncIterableIterator<Tx>;
+
   /** Returns the number of pending txs in the mempool. */
   getPendingTxCount(): Promise<number>;
 
   /**
-   * Marks transactions as non-evictable in the pool.
-   * @param txHashes - Hashes of the transactions to mark as non-evictable.
+   * Protects existing transactions by hash for a given slot.
+   * Returns hashes of transactions that weren't found in the pool.
+   * @param txHashes - Hashes of the transactions to protect.
+   * @param blockHeader - The block header providing slot context.
+   * @returns Hashes of transactions not found in the pool.
+   */
+  protectTxs(txHashes: TxHash[], blockHeader: BlockHeader): Promise<TxHash[]>;
+
+  /**
+   * Prepares the pool for a new slot.
+   * Unprotects transactions from earlier slots and validates them before
+   * returning to pending state.
+   * @param slotNumber - The slot number to prepare for
    */
-  markTxsAsNonEvictable(txHashes: TxHash[]): Promise<void>;
+  prepareForSlot(slotNumber: SlotNumber): Promise<void>;
 
   /**
    * Starts the p2p client.
@@ -174,6 +219,9 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
   /** Identifies a p2p client. */
   isP2PClient(): true;
 
+  /** Returns the tx provider used for fetching transactions. */
+  getTxProvider(): ITxProvider;
+
   updateP2PConfig(config: Partial<P2PConfig>): Promise<void>;
 
   /** Validates a set of txs. */
@@ -190,6 +238,12 @@ export type P2P<T extends P2PClientType = P2PClientType.Full> = P2PApiFull<T> &
 
   handleAuthRequestFromPeer(authRequest: AuthRequest, peerId: PeerId): Promise<StatusMessage>;
 
+  /** Checks if any block proposals exist for the given slot. */
+  hasBlockProposalsForSlot(slot: SlotNumber): Promise<boolean>;
+
   /** If node running this P2P stack is validator, passes in validator address to P2P layer */
   registerThisValidatorAddresses(address: EthAddress[]): void;
+
+  /** Returns the number of peers in the GossipSub mesh for a given topic type. */
+  getGossipMeshPeerCount(topicType: TopicType): Promise<number>;
 };