@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/mem_pools/tx_pool/tx_pool.ts

@@ -1,76 +0,0 @@
-import type { Tx, TxHash } from '@aztec/stdlib/tx';
-
-/**
- * Interface of a transaction pool. The pool includes tx requests and is kept up-to-date by a P2P client.
- */
-export interface TxPool {
-  /**
-   * Adds a list of transactions to the pool. Duplicates are ignored.
-   * @param txs - An array of txs to be added to the pool.
-   */
-  addTxs(txs: Tx[]): Promise<void>;
-
-  /**
-   * Checks if a transaction exists in the pool and returns it.
-   * @param txHash - The hash of the transaction, used as an ID.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
-  /**
-   * Checks if an archived transaction exists in the pool and returns it.
-   * @param txHash - The hash of the transaction, used as an ID.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */
-  getArchivedTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-
-  /**
-   * Marks the set of txs as mined, as opposed to pending.
-   * @param txHashes - Hashes of the txs to flag as mined.
-   */
-  markAsMined(txHashes: TxHash[], blockNumber: number): Promise<void>;
-
-  /**
-   * Moves mined txs back to the pending set in the case of a reorg.
-   * Note: txs not known by this peer will be ignored.
-   * @param txHashes - Hashes of the txs to flag as pending.
-   */
-  markMinedAsPending(txHashes: TxHash[]): Promise<void>;
-
-  /**
-   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-   * @param txHashes - An array of tx hashes to be removed from the tx pool.
-   */
-  deleteTxs(txHashes: TxHash[]): Promise<void>;
-
-  /**
-   * Gets all transactions currently in the tx pool.
-   * @returns An array of transaction objects found in the tx pool.
-   */
-  getAllTxs(): Promise<Tx[]>;
-
-  /**
-   * Gets the hashes of all transactions currently in the tx pool.
-   * @returns An array of transaction hashes found in the tx pool.
-   */
-  getAllTxHashes(): Promise<TxHash[]>;
-
-  /**
-   * Gets the hashes of pending transactions currently in the tx pool sorted by priority (see getPendingTxPriority).
-   * @returns An array of pending transaction hashes found in the tx pool.
-   */
-  getPendingTxHashes(): Promise<TxHash[]>;
-
-  /**
-   * Gets the hashes of mined transactions currently in the tx pool.
-   * @returns An array of mined transaction hashes found in the tx pool.
-   */
-  getMinedTxHashes(): Promise<[tx: TxHash, blockNumber: number][]>;
-
-  /**
-   * 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: TxHash): Promise<'pending' | 'mined' | undefined>;
-}

package/src/mem_pools/tx_pool/tx_pool_test_suite.ts

@@ -1,130 +0,0 @@
-import { unfreeze } from '@aztec/foundation/types';
-import { GasFees } from '@aztec/stdlib/gas';
-import { mockTx } from '@aztec/stdlib/testing';
-import type { Tx } from '@aztec/stdlib/tx';
-
-import type { TxPool } from './tx_pool.js';
-
-/**
- * Tests a TxPool implementation.
- * @param getTxPool - Gets a fresh TxPool
- */
-export function describeTxPool(getTxPool: () => TxPool) {
-  let pool: TxPool;
-
-  beforeEach(() => {
-    pool = getTxPool();
-  });
-
-  it('Adds txs to the pool as pending', async () => {
-    const tx1 = await mockTx();
-
-    await pool.addTxs([tx1]);
-    const poolTx = await pool.getTxByHash(await tx1.getTxHash());
-    expect(await poolTx!.getTxHash()).toEqual(await tx1.getTxHash());
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('pending');
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]);
-  });
-
-  it('Removes txs from the pool', async () => {
-    const tx1 = await mockTx();
-
-    await pool.addTxs([tx1]);
-    await pool.deleteTxs([await tx1.getTxHash()]);
-
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toBeFalsy();
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toBeUndefined();
-  });
-
-  it('Marks txs as mined', async () => {
-    const tx1 = await mockTx(1);
-    const tx2 = await mockTx(2);
-
-    await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
-
-    await expect(pool.getTxByHash(await tx1.getTxHash())).resolves.toEqual(tx1);
-    await expect(pool.getTxStatus(await tx1.getTxHash())).resolves.toEqual('mined');
-    await expect(pool.getMinedTxHashes()).resolves.toEqual([[await tx1.getTxHash(), 1]]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx2.getTxHash()]);
-  });
-
-  it('Marks txs as pending after being mined', async () => {
-    const tx1 = await mockTx(1);
-    const tx2 = await mockTx(2);
-
-    await pool.addTxs([tx1, tx2]);
-    await pool.markAsMined([await tx1.getTxHash()], 1);
-
-    await pool.markMinedAsPending([await tx1.getTxHash()]);
-    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-    const pending = await pool.getPendingTxHashes();
-    expect(pending).toHaveLength(2);
-    expect(pending).toEqual(expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash()]));
-  });
-
-  it('Only marks txs as pending if they are known', async () => {
-    const tx1 = await mockTx(1);
-    // simulate a situation where not all peers have all the txs
-    const tx2 = await mockTx(2);
-    const someTxHashThatThisPeerDidNotSee = await tx2.getTxHash();
-    await pool.addTxs([tx1]);
-    // this peer knows that tx2 was mined, but it does not have the tx object
-    await pool.markAsMined([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee], 1);
-    expect(await pool.getMinedTxHashes()).toEqual(
-      expect.arrayContaining([
-        [await tx1.getTxHash(), 1],
-        [someTxHashThatThisPeerDidNotSee, 1],
-      ]),
-    );
-
-    // reorg: both txs should now become available again
-    await pool.markMinedAsPending([await tx1.getTxHash(), someTxHashThatThisPeerDidNotSee]);
-    await expect(pool.getMinedTxHashes()).resolves.toEqual([]);
-    await expect(pool.getPendingTxHashes()).resolves.toEqual([await tx1.getTxHash()]); // tx2 is not in the pool
-  });
-
-  it('Returns all transactions in the pool', async () => {
-    const tx1 = await mockTx(1);
-    const tx2 = await mockTx(2);
-    const tx3 = await mockTx(3);
-
-    await pool.addTxs([tx1, tx2, tx3]);
-
-    const poolTxs = await pool.getAllTxs();
-    expect(poolTxs).toHaveLength(3);
-    expect(poolTxs).toEqual(expect.arrayContaining([tx1, tx2, tx3]));
-  });
-
-  it('Returns all txHashes in the pool', async () => {
-    const tx1 = await mockTx(1);
-    const tx2 = await mockTx(2);
-    const tx3 = await mockTx(3);
-
-    await pool.addTxs([tx1, tx2, tx3]);
-
-    const poolTxHashes = await pool.getAllTxHashes();
-    expect(poolTxHashes).toHaveLength(3);
-    expect(poolTxHashes).toEqual(
-      expect.arrayContaining([await tx1.getTxHash(), await tx2.getTxHash(), await tx3.getTxHash()]),
-    );
-  });
-
-  it('Returns pending tx hashes sorted by priority', async () => {
-    const withPriorityFee = (tx: Tx, fee: number) => {
-      unfreeze(tx.data.constants.txContext.gasSettings).maxPriorityFeesPerGas = new GasFees(fee, fee);
-      return tx;
-    };
-
-    const tx1 = withPriorityFee(await mockTx(0), 1000);
-    const tx2 = withPriorityFee(await mockTx(1), 100);
-    const tx3 = withPriorityFee(await mockTx(2), 200);
-    const tx4 = withPriorityFee(await mockTx(3), 3000);
-
-    await pool.addTxs([tx1, tx2, tx3, tx4]);
-
-    const poolTxHashes = await pool.getPendingTxHashes();
-    expect(poolTxHashes).toHaveLength(4);
-    expect(poolTxHashes).toEqual(await Promise.all([tx4, tx1, tx3, tx2].map(tx => tx.getTxHash())));
-  });
-}

package/src/msg_validators/block_proposal_validator/block_proposal_validator.ts

@@ -1,29 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-
-export class BlockProposalValidator implements P2PValidator<BlockProposal> {
-  private epochCache: EpochCacheInterface;
-
-  constructor(epochCache: EpochCacheInterface) {
-    this.epochCache = epochCache;
-  }
-
-  async validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined> {
-    const { currentProposer, nextProposer, currentSlot, nextSlot } =
-      await this.epochCache.getProposerInCurrentOrNextSlot();
-
-    // Check that the attestation is for the current or next slot
-    const slotNumberBigInt = block.payload.header.globalVariables.slotNumber.toBigInt();
-    if (slotNumberBigInt !== currentSlot && slotNumberBigInt !== nextSlot) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
-
-    // Check that the block proposal is from the current or next proposer
-    const proposer = await block.getSender();
-    if (!proposer.equals(currentProposer) && !proposer.equals(nextProposer)) {
-      return PeerErrorSeverity.HighToleranceError;
-    }
-
-    return undefined;
-  }
-}

package/src/msg_validators/block_proposal_validator/index.ts

@@ -1 +0,0 @@
-export * from './block_proposal_validator.js';

package/src/services/reqresp/connection-sampler/batch_connection_sampler.ts

@@ -1,94 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { ConnectionSampler } from './connection_sampler.js';
-
-/**
- * Manages batches of peers for parallel request processing.
- * Tracks active peers and provides deterministic peer assignment for requests.
- *
- * Example with 3 peers and 10 requests:
- *
- * Peers:    [P1]      [P2]     [P3]
- *           ↓ ↓ ↓ ↓   ↓ ↓ ↓   ↓ ↓ ↓
- * Requests: 0,1,2,9 | 3,4,5 | 6,7,8
- *
- * Each peer handles a bucket of consecutive requests.
- * If a peer fails, it is replaced while maintaining the same bucket.
- */
-export class BatchConnectionSampler {
-  private readonly logger = createLogger('p2p:reqresp:batch-connection-sampler');
-  private readonly batch: PeerId[] = [];
-  private readonly requestsPerPeer: number;
-
-  constructor(private readonly connectionSampler: ConnectionSampler, batchSize: number, maxPeers: number) {
-    if (maxPeers <= 0) {
-      throw new Error('Max peers cannot be 0');
-    }
-    if (batchSize <= 0) {
-      throw new Error('Batch size cannot be 0');
-    }
-
-    // Calculate how many requests each peer should handle, cannot be 0
-    this.requestsPerPeer = Math.max(1, Math.floor(batchSize / maxPeers));
-
-    // Sample initial peers
-    this.batch = this.connectionSampler.samplePeersBatch(maxPeers);
-  }
-
-  /**
-   * Gets the peer responsible for handling a specific request index
-   *
-   * @param index - The request index
-   * @returns The peer assigned to handle this request
-   */
-  getPeerForRequest(index: number): PeerId | undefined {
-    if (this.batch.length === 0) {
-      return undefined;
-    }
-
-    // Calculate which peer bucket this index belongs to
-    const peerIndex = Math.floor(index / this.requestsPerPeer) % this.batch.length;
-    return this.batch[peerIndex];
-  }
-
-  /**
-   * Removes a peer and replaces it with a new one, maintaining the same position
-   * in the batch array to keep request distribution consistent
-   *
-   * @param peerId - The peer to remove and replace
-   */
-  removePeerAndReplace(peerId: PeerId): void {
-    const index = this.batch.findIndex(p => p === peerId);
-    if (index === -1) {
-      return;
-    }
-
-    const excluding = new Map([[peerId.toString(), true]]);
-    const newPeer = this.connectionSampler.getPeer(excluding);
-
-    if (newPeer) {
-      this.batch[index] = newPeer;
-      this.logger.trace(`Replaced peer ${peerId} with ${newPeer}`, { peerId, newPeer });
-    } else {
-      // If we couldn't get a replacement, remove the peer and compact the array
-      this.batch.splice(index, 1);
-      this.logger.trace(`Removed peer ${peerId}`, { peerId });
-    }
-  }
-
-  /**
-   * Gets the number of active peers
-   */
-  get activePeerCount(): number {
-    return this.batch.length;
-  }
-
-  /**
-   * Gets the number of requests each peer is assigned to handle
-   */
-  get requestsPerBucket(): number {
-    return this.requestsPerPeer;
-  }
-}

package/src/services/reqresp/protocols/block.ts

@@ -1,15 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import type { L2BlockSource } from '@aztec/stdlib/block';
-
-import type { PeerId } from '@libp2p/interface';
-
-import type { ReqRespSubProtocolHandler } from '../interface.js';
-
-export function reqRespBlockHandler(l2BlockSource: L2BlockSource): ReqRespSubProtocolHandler {
-  return async (_peerId: PeerId, msg: Buffer) => {
-    const blockNumber = Fr.fromBuffer(msg);
-
-    const foundBlock = await l2BlockSource.getBlock(Number(blockNumber));
-    return foundBlock ? foundBlock.toBuffer() : Buffer.alloc(0);
-  };
-}