@aztec/p2p 0.0.1-commit.b655e406 → 0.0.1-commit.d1f2d6c

package/src/services/tx_provider.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { compactArray } from '@aztec/foundation/collection';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
@@ -55,7 +56,7 @@ export class TxProvider implements ITxProvider {
   /** Gathers txs from the tx pool, proposal body, remote rpc nodes, and reqresp. */
   public getTxsForBlockProposal(
     blockProposal: BlockProposal,
-    blockNumber: number,
+    blockNumber: BlockNumber,
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }> {
     return this.getOrderedTxsFromAllSources(
@@ -136,6 +137,7 @@ export class TxProvider implements ITxProvider {
     );
 
     if (missingTxHashes.size === 0) {
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
       return { txsFromMempool };
     }
 
@@ -154,24 +156,26 @@ export class TxProvider implements ITxProvider {
 
     if (missingTxHashes.size === 0) {
       await this.processProposalTxs(txsFromProposal);
+      this.instrumentation.incTxsFromP2P(0, txHashes.length);
       return { txsFromMempool, txsFromProposal };
     }
 
     // Start tx collection from the network if needed, while we validate the txs taken from the proposal in parallel
     const [txsFromNetwork] = await Promise.all([
-      this.txCollection.collectFastFor(request, [...missingTxHashes], opts),
+      this.collectFromP2P(request, [...missingTxHashes], opts),
       this.processProposalTxs(txsFromProposal),
     ] as const);
 
     if (txsFromNetwork.length > 0) {
       txsFromNetwork.forEach(tx => missingTxHashes.delete(tx.txHash.toString()));
-      this.instrumentation.incTxsFromP2P(txsFromNetwork.length);
       this.log.debug(
         `Retrieved ${txsFromNetwork.length} txs from network for block proposal (${missingTxHashes.size} pending)`,
         { ...blockInfo, missingTxHashes: [...missingTxHashes] },
       );
     }
 
+    this.instrumentation.incTxsFromP2P(txsFromNetwork.length, txHashes.length);
+
     if (missingTxHashes.size === 0) {
       return { txsFromNetwork, txsFromMempool, txsFromProposal };
     }
@@ -199,6 +203,18 @@ export class TxProvider implements ITxProvider {
     };
   }
 
+  private async collectFromP2P(
+    input: FastCollectionRequestInput,
+    txHashes: TxHash[] | string[],
+    opts: { deadline: Date; pinnedPeer?: PeerId },
+  ): Promise<Tx[]> {
+    const requestedAt = Date.now();
+    const result = await this.txCollection.collectFastFor(input, txHashes, opts);
+    const requestProcessedAt = Date.now();
+    this.instrumentation.recordTxsRequestDelay(requestProcessedAt - requestedAt);
+    return result;
+  }
+
   private extractFromProposal(proposal: BlockProposal | undefined, missingTxHashes: string[]): Tx[] {
     if (!proposal) {
       return [];

package/src/services/tx_provider_instrumentation.ts

@@ -1,4 +1,4 @@
-import { Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+import { type Histogram, Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
 
 export class TxProviderInstrumentation {
   private txFromProposalCount: UpDownCounter;
@@ -6,24 +6,23 @@ export class TxProviderInstrumentation {
   private txFromP2PCount: UpDownCounter;
   private missingTxsCount: UpDownCounter;
 
+  private fractionOfTxsRequestedFromP2P: Histogram;
+  private txsRequestDelay: Histogram;
+
   constructor(client: TelemetryClient, name: string) {
     const meter = client.getMeter(name);
 
-    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT, {
-      description: 'The number of txs taken from block proposals',
-    });
+    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_PROPOSALS_COUNT);
+
+    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT);
+
+    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT);
 
-    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_MEMPOOL_COUNT, {
-      description: 'The number of txs taken from the local mempool',
-    });
+    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_MISSING_TXS_COUNT);
 
-    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_TXS_FROM_P2P_COUNT, {
-      description: 'The number of txs taken from the p2p network',
-    });
+    this.fractionOfTxsRequestedFromP2P = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUESTED_FRACTION);
 
-    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_PROVIDER_MISSING_TXS_COUNT, {
-      description: 'The number of txs not found anywhere',
-    });
+    this.txsRequestDelay = meter.createHistogram(Metrics.TX_PROVIDER_P2P_TXS_REQUEST_DELAY);
   }
 
   incTxsFromProposals(count: number) {
@@ -34,8 +33,13 @@ export class TxProviderInstrumentation {
     this.txFromMempoolCount.add(count);
   }
 
-  incTxsFromP2P(count: number) {
+  incTxsFromP2P(count: number, total: number) {
     this.txFromP2PCount.add(count);
+    this.fractionOfTxsRequestedFromP2P.record(count / total);
+  }
+
+  recordTxsRequestDelay(delay: number) {
+    this.txsRequestDelay.record(delay);
   }
 
   incMissingTxs(count: number) {

package/src/test-helpers/mock-pubsub.ts

@@ -39,7 +39,7 @@ export function getMockPubSubP2PServiceFactory<T extends P2PClientType>(
     peerId: PeerId,
     deps: {
       packageVersion: string;
-      mempools: MemPools<T>;
+      mempools: MemPools;
       l2BlockSource: L2BlockSource & ContractDataSource;
       epochCache: EpochCacheInterface;
       proofVerifier: ClientProtocolCircuitVerifier;

package/src/test-helpers/mock-tx-helpers.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree';
 import { protocolContractsHash } from '@aztec/protocol-contracts';
 import { mockTx } from '@aztec/stdlib/testing';

package/src/test-helpers/reqresp-nodes.ts

@@ -112,7 +112,7 @@ export async function createTestLibP2PService<T extends P2PClientType>(
   archiver: L2BlockSource & ContractDataSource,
   worldStateSynchronizer: WorldStateSynchronizer,
   epochCache: EpochCache,
-  mempools: MemPools<T>,
+  mempools: MemPools,
   telemetry: TelemetryClient,
   port: number = 0,
   peerId?: PeerId,

package/src/testbench/p2p_client_testbench_worker.ts

@@ -5,7 +5,8 @@
  */
 import { MockL2BlockSource } from '@aztec/archiver/test';
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { EthAddress } from '@aztec/foundation/eth-address';
+import { EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { SecretValue } from '@aztec/foundation/config';
 import { createLogger } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import type { DataStoreConfig } from '@aztec/kv-store/config';
@@ -55,6 +56,7 @@ function mockTxPool(): TxPool {
     hasTx: () => Promise.resolve(false),
     updateConfig: () => {},
     markTxsAsNonEvictable: () => Promise.resolve(),
+    clearNonEvictableTxs: () => Promise.resolve(),
     cleanupDeletedMinedTxs: () => Promise.resolve(0),
   };
   return Object.assign(new EventEmitter(), pool);
@@ -63,34 +65,38 @@ function mockTxPool(): TxPool {
 function mockAttestationPool(): AttestationPool {
   return {
     isEmpty: () => Promise.resolve(false),
-    addAttestations: () => Promise.resolve(),
-    deleteAttestations: () => Promise.resolve(),
-    deleteAttestationsOlderThan: () => Promise.resolve(),
-    deleteAttestationsForSlot: () => Promise.resolve(),
-    deleteAttestationsForSlotAndProposal: () => Promise.resolve(),
-    getAttestationsForSlot: () => Promise.resolve([]),
-    getAttestationsForSlotAndProposal: () => Promise.resolve([]),
     addBlockProposal: () => Promise.resolve(),
     getBlockProposal: () => Promise.resolve(undefined),
     hasBlockProposal: () => Promise.resolve(false),
-    hasAttestation: () => Promise.resolve(false),
+    canAddProposal: () => Promise.resolve(true),
+    // Checkpoint attestation methods
+    addCheckpointProposal: () => Promise.resolve(),
+    getCheckpointProposal: () => Promise.resolve(undefined),
+    hasCheckpointProposal: () => Promise.resolve(false),
+    addCheckpointAttestations: () => Promise.resolve(),
+    getCheckpointAttestationsForSlot: () => Promise.resolve([]),
+    getCheckpointAttestationsForSlotAndProposal: () => Promise.resolve([]),
+    deleteCheckpointAttestationsOlderThan: () => Promise.resolve(),
+    hasReachedCheckpointProposalCap: () => Promise.resolve(false),
+    hasReachedCheckpointAttestationCap: () => Promise.resolve(false),
+    canAddCheckpointProposal: () => Promise.resolve(true),
+    canAddCheckpointAttestation: () => Promise.resolve(true),
+    hasCheckpointAttestation: () => Promise.resolve(false),
   };
 }
 
 function mockEpochCache(): EpochCacheInterface {
   return {
-    getCommittee: () => Promise.resolve({ committee: [], seed: 1n, epoch: 0n }),
+    getCommittee: () => Promise.resolve({ committee: [], seed: 1n, epoch: EpochNumber.ZERO, isEscapeHatchOpen: false }),
     getProposerIndexEncoding: () => '0x' as `0x${string}`,
-    getEpochAndSlotNow: () => ({ epoch: 0n, slot: 0n, ts: 0n }),
+    getEpochAndSlotNow: () => ({ epoch: EpochNumber.ZERO, slot: SlotNumber.ZERO, ts: 0n, nowMs: 0n }),
     computeProposerIndex: () => 0n,
-    getProposerAttesterAddressInCurrentOrNextSlot: () =>
-      Promise.resolve({
-        currentProposer: EthAddress.ZERO,
-        nextProposer: EthAddress.ZERO,
-        currentSlot: 0n,
-        nextSlot: 0n,
-      }),
-    getEpochAndSlotInNextL1Slot: () => ({ epoch: 0n, slot: 0n, ts: 0n, now: 0n }),
+    getCurrentAndNextSlot: () => ({
+      currentSlot: SlotNumber.ZERO,
+      nextSlot: SlotNumber.ZERO,
+    }),
+    getProposerAttesterAddressInSlot: () => Promise.resolve(undefined),
+    getEpochAndSlotInNextL1Slot: () => ({ epoch: EpochNumber.ZERO, slot: SlotNumber.ZERO, ts: 0n, now: 0n }),
     isInCommittee: () => Promise.resolve(false),
     getRegisteredValidators: () => Promise.resolve([]),
     filterInCommittee: () => Promise.resolve([]),
@@ -123,7 +129,7 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
     peerDiscoveryService: PeerDiscoveryService,
     reqresp: ReqResp,
     peerManager: PeerManager,
-    mempools: MemPools<T>,
+    mempools: MemPools,
     archiver: L2BlockSource & ContractDataSource,
     epochCache: EpochCacheInterface,
     proofVerifier: ClientProtocolCircuitVerifier,
@@ -185,9 +191,25 @@ class TestLibP2PService<T extends P2PClientType = P2PClientType.Full> extends Li
 
 // eslint-disable-next-line @typescript-eslint/no-misused-promises
 process.on('message', async msg => {
-  const { type, config, clientIndex } = msg as { type: string; config: P2PConfig; clientIndex: number };
+  // Note: peerIdPrivateKey comes as a raw string (not SecretValue) because
+  // SecretValue's private fields can't be serialized via IPC
+  const {
+    type,
+    config: rawConfig,
+    clientIndex,
+  } = msg as {
+    type: string;
+    config: Omit<P2PConfig, 'peerIdPrivateKey'> & { peerIdPrivateKey?: string };
+    clientIndex: number;
+  };
   try {
     if (type === 'START') {
+      // Re-wrap the peerIdPrivateKey with SecretValue
+      const config: P2PConfig = {
+        ...rawConfig,
+        peerIdPrivateKey: rawConfig.peerIdPrivateKey ? new SecretValue(rawConfig.peerIdPrivateKey) : undefined,
+      } as P2PConfig;
+
       const txPool = mockTxPool();
       const attestationPool = mockAttestationPool();
       const epochCache = mockEpochCache();
@@ -220,14 +242,15 @@ process.on('message', async msg => {
       );
 
       // Create test service with validation disabled
+      // Note: Parameter order must match LibP2PService constructor
       const testService = new TestLibP2PService(
         P2PClientType.Full,
         config,
         (client as any).p2pService.node,
         (client as any).p2pService.peerDiscoveryService,
-        (client as any).p2pService.mempools,
         (client as any).p2pService.reqresp,
         (client as any).p2pService.peerManager,
+        (client as any).p2pService.mempools,
         (client as any).p2pService.archiver,
         epochCache,
         proofVerifier,

package/src/testbench/worker_client_manager.ts

@@ -73,7 +73,12 @@ class WorkerClientManager {
     clientIndex: number,
   ): [ChildProcess, Promise<void>] {
     const childProcess = fork(workerPath);
-    childProcess.send({ type: 'START', config, clientIndex });
+    // Extract the raw peerIdPrivateKey value since SecretValue can't be serialized via IPC
+    const serializedConfig = {
+      ...config,
+      peerIdPrivateKey: config.peerIdPrivateKey?.getValue(),
+    };
+    childProcess.send({ type: 'START', config: serializedConfig, clientIndex });
 
     // Handle unexpected child process exit
     childProcess.on('exit', (code, signal) => {

package/src/util.ts

@@ -12,6 +12,7 @@ import { createFromPrivKey } from '@libp2p/peer-id-factory';
 import { resolve } from 'dns/promises';
 import { promises as fs } from 'fs';
 import type { Libp2p } from 'libp2p';
+import net from 'net';
 import path from 'path';
 
 import type { P2PConfig } from './config.js';
@@ -56,9 +57,18 @@ export function convertToMultiaddr(address: string, port: number, protocol: 'tcp
  * Queries the public IP address of the machine.
  */
 export async function getPublicIp(): Promise<string> {
-  const resp = await fetch('http://checkip.amazonaws.com/');
+  const resp = await fetch('https://checkip.amazonaws.com/');
   const text = await resp.text();
-  return text.trim();
+  const address = text.trim();
+  if (!isValidIpAddress(address)) {
+    throw new Error(`Received invalid IP address from checkip service: ${address}`);
+  }
+  return address;
+}
+
+export function isValidIpAddress(address: string): boolean {
+  const netType = net.isIP(address);
+  return netType === 4;
 }
 
 export async function resolveAddressIfNecessary(address: string, port: string): Promise<string> {

package/dest/mem_pools/tx_pool/memory_tx_pool.d.ts

@@ -1,80 +0,0 @@
-import type { TypedEventEmitter } from '@aztec/foundation/types';
-import { BlockHeader, Tx, TxHash } from '@aztec/stdlib/tx';
-import { type TelemetryClient } from '@aztec/telemetry-client';
-import type { TxPool, TxPoolEvents, TxPoolOptions } from './tx_pool.js';
-declare const InMemoryTxPool_base: new () => TypedEventEmitter<TxPoolEvents>;
-/**
- * In-memory implementation of the Transaction Pool.
- */
-export declare class InMemoryTxPool extends InMemoryTxPool_base implements TxPool {
-    private log;
-    /**
-     * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
-     */
-    private txs;
-    private minedTxs;
-    private pendingTxs;
-    private deletedMinedTxHashes;
-    private blockToDeletedMinedTxHash;
-    private metrics;
-    /**
-     * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
-     * @param log - A logger.
-     */
-    constructor(telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
-    private countTx;
-    isEmpty(): Promise<boolean>;
-    markAsMined(txHashes: TxHash[], blockHeader: BlockHeader): Promise<void>;
-    markMinedAsPending(txHashes: TxHash[]): Promise<void>;
-    getPendingTxHashes(): Promise<TxHash[]>;
-    getMinedTxHashes(): Promise<[TxHash, number][]>;
-    getPendingTxCount(): Promise<number>;
-    getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | 'deleted' | undefined>;
-    /**
-     * Checks if a transaction exists in the pool and returns it.
-     * @param txHash - The generated tx hash.
-     * @returns The transaction, if found, 'undefined' otherwise.
-     */
-    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
-    getTxsByHash(txHashes: TxHash[]): Promise<(Tx | undefined)[]>;
-    hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
-    hasTx(txHash: TxHash): Promise<boolean>;
-    getArchivedTxByHash(): Promise<Tx | undefined>;
-    /**
-     * Adds a list of transactions to the pool. Duplicates are ignored.
-     * @param txs - An array of txs to be added to the pool.
-     * @returns Empty promise.
-     */
-    addTxs(txs: Tx[], opts?: {
-        source?: string;
-    }): Promise<number>;
-    /**
-     * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-     * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
-     * @param txHashes - An array of tx hashes to be deleted from the tx pool.
-     * @returns Empty promise.
-     */
-    deleteTxs(txHashes: TxHash[], opts?: {
-        permanently?: boolean;
-    }): Promise<void>;
-    /**
-     * Gets all the transactions stored in the pool.
-     * @returns Array of tx objects in the order they were added to the 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[]>;
-    updateConfig(_config: TxPoolOptions): void;
-    markTxsAsNonEvictable(_: TxHash[]): Promise<void>;
-    /**
-     * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
-     * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
-     * @returns The number of transactions permanently deleted.
-     */
-    cleanupDeletedMinedTxs(blockNumber: number): Promise<number>;
-}
-export {};
-//# sourceMappingURL=memory_tx_pool.d.ts.map

package/dest/mem_pools/tx_pool/memory_tx_pool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory_tx_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool/memory_tx_pool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAMnF,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;mCAKnB,UAAU,iBAAiB,CAAC,YAAY,CAAC;AAH9F;;GAEG;AACH,qBAAa,cAAe,SAAQ,mBAA4D,YAAW,MAAM;IAkB7G,OAAO,CAAC,GAAG;IAjBb;;OAEG;IACH,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAsB;IACtC,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,oBAAoB,CAAsB;IAClD,OAAO,CAAC,yBAAyB,CAA2B;IAE5D,OAAO,CAAC,OAAO,CAA0B;IAEzC;;;OAGG;gBAED,SAAS,GAAE,eAAsC,EACzC,GAAG,yCAA8B;IAW3C,OAAO,CAAC,OAAO,CAOb;IAEK,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAI3B,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBxE,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB/C,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAa7C,gBAAgB,IAAI,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAM/C,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IAKpC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IAexF;;;;OAIG;IACI,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAK3D,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,CAAC;IAG7D,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IAIxC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKtC,mBAAmB,IAAI,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IAIrD;;;;OAIG;IACI,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,IAAI,GAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IA0BzE;;;;;OAKG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BrF;;;OAGG;IACI,SAAS,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;IAIjC;;;OAGG;IACI,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAI1C,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI;IAE1C,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjD;;;;OAIG;IACI,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CA2BpE"}

package/dest/mem_pools/tx_pool/memory_tx_pool.js

@@ -1,238 +0,0 @@
-import { createLogger } from '@aztec/foundation/log';
-import { Tx, TxHash } from '@aztec/stdlib/tx';
-import { getTelemetryClient } from '@aztec/telemetry-client';
-import EventEmitter from 'node:events';
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
-import { getPendingTxPriority } from './priority.js';
-/**
- * In-memory implementation of the Transaction Pool.
- */ export class InMemoryTxPool extends EventEmitter {
-    log;
-    /**
-   * Our tx pool, stored as a Map in-memory, with K: tx hash and V: the transaction.
-   */ txs;
-    minedTxs;
-    pendingTxs;
-    deletedMinedTxHashes;
-    blockToDeletedMinedTxHash;
-    metrics;
-    /**
-   * Class constructor for in-memory TxPool. Initiates our transaction pool as a JS Map.
-   * @param log - A logger.
-   */ constructor(telemetry = getTelemetryClient(), log = createLogger('p2p:tx_pool')){
-        super(), this.log = log, this.countTx = ()=>{
-            return Promise.resolve({
-                itemCount: {
-                    mined: this.minedTxs.size,
-                    pending: this.pendingTxs.size
-                }
-            });
-        };
-        this.txs = new Map();
-        this.minedTxs = new Map();
-        this.pendingTxs = new Set();
-        this.deletedMinedTxHashes = new Map();
-        this.blockToDeletedMinedTxHash = new Map();
-        this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTx);
-    }
-    countTx;
-    isEmpty() {
-        return Promise.resolve(this.txs.size === 0);
-    }
-    markAsMined(txHashes, blockHeader) {
-        const keys = txHashes.map((x)=>x.toBigInt());
-        for (const key of keys){
-            // If this tx was previously soft-deleted, remove it from the deleted sets
-            if (this.deletedMinedTxHashes.has(key)) {
-                const originalBlock = this.deletedMinedTxHashes.get(key);
-                this.deletedMinedTxHashes.delete(key);
-                // Remove from block-to-hash mapping
-                const txHashesForBlock = this.blockToDeletedMinedTxHash.get(originalBlock);
-                if (txHashesForBlock) {
-                    txHashesForBlock.delete(key);
-                    if (txHashesForBlock.size === 0) {
-                        this.blockToDeletedMinedTxHash.delete(originalBlock);
-                    }
-                }
-            }
-            this.minedTxs.set(key, blockHeader.globalVariables.blockNumber);
-            this.pendingTxs.delete(key);
-        }
-        return Promise.resolve();
-    }
-    markMinedAsPending(txHashes) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        const keys = txHashes.map((x)=>x.toBigInt());
-        for (const key of keys){
-            this.minedTxs.delete(key);
-            // only add back to the pending set if we have the tx object
-            if (this.txs.has(key)) {
-                this.pendingTxs.add(key);
-            }
-        }
-        return Promise.resolve();
-    }
-    async getPendingTxHashes() {
-        const txs = (await this.getAllTxs()).sort((tx1, tx2)=>-getPendingTxPriority(tx1).localeCompare(getPendingTxPriority(tx2)));
-        const txHashes = await Promise.all(txs.map((tx)=>tx.getTxHash()));
-        // No need to check deleted since pending txs are never soft-deleted
-        return txHashes.filter((txHash)=>{
-            const key = txHash.toBigInt();
-            return this.pendingTxs.has(key);
-        });
-    }
-    getMinedTxHashes() {
-        return Promise.resolve(Array.from(this.minedTxs.entries()).map(([txHash, blockNumber])=>[
-                TxHash.fromBigInt(txHash),
-                blockNumber
-            ]));
-    }
-    getPendingTxCount() {
-        // Soft-deleted transactions are always mined, never pending
-        return Promise.resolve(this.pendingTxs.size);
-    }
-    getTxStatus(txHash) {
-        const key = txHash.toBigInt();
-        if (this.deletedMinedTxHashes.has(key)) {
-            return Promise.resolve('deleted');
-        }
-        if (this.minedTxs.has(key)) {
-            return Promise.resolve('mined');
-        }
-        if (this.pendingTxs.has(key)) {
-            return Promise.resolve('pending');
-        }
-        return Promise.resolve(undefined);
-    }
-    /**
-   * Checks if a transaction exists in the pool and returns it.
-   * @param txHash - The generated tx hash.
-   * @returns The transaction, if found, 'undefined' otherwise.
-   */ getTxByHash(txHash) {
-        const result = this.txs.get(txHash.toBigInt());
-        return Promise.resolve(result === undefined ? undefined : Tx.clone(result));
-    }
-    getTxsByHash(txHashes) {
-        return Promise.all(txHashes.map((txHash)=>this.getTxByHash(txHash)));
-    }
-    hasTxs(txHashes) {
-        return Promise.resolve(txHashes.map((txHash)=>this.txs.has(txHash.toBigInt())));
-    }
-    async hasTx(txHash) {
-        const result = await this.hasTxs([
-            txHash
-        ]);
-        return result[0];
-    }
-    getArchivedTxByHash() {
-        return Promise.resolve(undefined);
-    }
-    /**
-   * Adds a list of transactions to the pool. Duplicates are ignored.
-   * @param txs - An array of txs to be added to the pool.
-   * @returns Empty promise.
-   */ addTxs(txs, opts = {}) {
-        const added = [];
-        for (const tx of txs){
-            const txHash = tx.getTxHash();
-            this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
-                eventName: 'tx-added-to-pool',
-                ...tx.getStats()
-            });
-            const key = txHash.toBigInt();
-            if (!this.txs.has(key)) {
-                added.push(tx);
-                this.txs.set(key, tx);
-            }
-            if (!this.minedTxs.has(key)) {
-                this.metrics.recordSize(tx);
-                this.pendingTxs.add(key);
-            }
-        }
-        if (added.length > 0) {
-            this.emit('txs-added', {
-                ...opts,
-                txs: added
-            });
-        }
-        return Promise.resolve(added.length);
-    }
-    /**
-   * Deletes transactions from the pool. Tx hashes that are not present are ignored.
-   * Mined transactions are soft-deleted with a timestamp, pending transactions are permanently deleted.
-   * @param txHashes - An array of tx hashes to be deleted from the tx pool.
-   * @returns Empty promise.
-   */ deleteTxs(txHashes, opts) {
-        for (const txHash of txHashes){
-            const key = txHash.toBigInt();
-            if (this.txs.has(key)) {
-                if (this.minedTxs.has(key)) {
-                    const blockNumber = this.minedTxs.get(key);
-                    this.minedTxs.delete(key);
-                    // Soft-delete mined transactions: remove from mined set but keep in storage
-                    if (opts?.permanently) {
-                        // Permanently delete mined transactions if specified
-                        this.txs.delete(key);
-                    } else {
-                        this.deletedMinedTxHashes.set(key, blockNumber);
-                        if (!this.blockToDeletedMinedTxHash.has(blockNumber)) {
-                            this.blockToDeletedMinedTxHash.set(blockNumber, new Set());
-                        }
-                        this.blockToDeletedMinedTxHash.get(blockNumber).add(key);
-                    }
-                } else {
-                    // Permanently delete pending transactions
-                    this.txs.delete(key);
-                    this.pendingTxs.delete(key);
-                }
-            }
-        }
-        return Promise.resolve();
-    }
-    /**
-   * Gets all the transactions stored in the pool.
-   * @returns Array of tx objects in the order they were added to the pool.
-   */ getAllTxs() {
-        return Promise.resolve(Array.from(this.txs.values()).map((x)=>Tx.clone(x)));
-    }
-    /**
-   * Gets the hashes of all transactions currently in the tx pool.
-   * @returns An array of transaction hashes found in the tx pool.
-   */ getAllTxHashes() {
-        return Promise.resolve(Array.from(this.txs.keys()).map((x)=>TxHash.fromBigInt(x)));
-    }
-    updateConfig(_config) {}
-    markTxsAsNonEvictable(_) {
-        return Promise.resolve();
-    }
-    /**
-   * Permanently deletes deleted mined transactions from blocks up to and including the specified block number.
-   * @param blockNumber - Block number threshold. Deleted mined txs from this block or earlier will be permanently deleted.
-   * @returns The number of transactions permanently deleted.
-   */ cleanupDeletedMinedTxs(blockNumber) {
-        let deletedCount = 0;
-        const blocksToDelete = [];
-        // Find all blocks up to the specified block number
-        for (const [block, txHashes] of this.blockToDeletedMinedTxHash.entries()){
-            if (block <= blockNumber) {
-                // Permanently delete all transactions from this block
-                for (const txHash of txHashes){
-                    this.txs.delete(txHash);
-                    this.deletedMinedTxHashes.delete(txHash);
-                    deletedCount++;
-                }
-                blocksToDelete.push(block);
-            }
-        }
-        // Clean up block-to-hash mapping
-        for (const block of blocksToDelete){
-            this.blockToDeletedMinedTxHash.delete(block);
-        }
-        if (deletedCount > 0) {
-            this.log.debug(`Permanently deleted ${deletedCount} deleted mined txs from blocks up to ${blockNumber}`);
-        }
-        return Promise.resolve(deletedCount);
-    }
-}

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.d.ts

@@ -1,12 +0,0 @@
-import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type BlockProposal, type P2PValidator, PeerErrorSeverity } from '@aztec/stdlib/p2p';
-export declare class BlockProposalValidator implements P2PValidator<BlockProposal> {
-    private epochCache;
-    private logger;
-    private txsPermitted;
-    constructor(epochCache: EpochCacheInterface, opts: {
-        txsPermitted: boolean;
-    });
-    validate(block: BlockProposal): Promise<PeerErrorSeverity | undefined>;
-}
-//# sourceMappingURL=block_proposal_validator.d.ts.map

package/dest/msg_validators/block_proposal_validator/block_proposal_validator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"block_proposal_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/block_proposal_validator/block_proposal_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAG9D,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE7F,qBAAa,sBAAuB,YAAW,YAAY,CAAC,aAAa,CAAC;IACxE,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,YAAY,CAAU;gBAElB,UAAU,EAAE,mBAAmB,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,OAAO,CAAA;KAAE;IAMtE,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;CAgE7E"}