@aztec/p2p 0.0.0-test.1 → 0.0.1-commit.24de95ac

package/src/config.ts

@@ -1,78 +1,64 @@
 import {
   type ConfigMappingsType,
+  SecretValue,
   booleanConfigHelper,
+  floatConfigHelper,
   getConfigFromMappings,
   getDefaultConfig,
   numberConfigHelper,
   pickConfigMappings,
+  secretStringConfigHelper,
 } from '@aztec/foundation/config';
+import { Fr } from '@aztec/foundation/fields';
 import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
-import { type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type AllowedElement, type ChainConfig, chainConfigMappings } from '@aztec/stdlib/config';
 
 import { type P2PReqRespConfig, p2pReqRespConfigMappings } from './services/reqresp/config.js';
+import { type TxCollectionConfig, txCollectionConfigMappings } from './services/tx_collection/config.js';
 
 /**
  * P2P client configuration values.
  */
-export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
-  /**
-   * A flag dictating whether the P2P subsystem should be enabled.
-   */
+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.
-   */
+  /** The frequency in which to check for new L2 blocks. */
   blockCheckIntervalMS: number;
 
-  /**
-   * The number of blocks to fetch in a single batch.
-   */
+  /** The number of blocks to fetch in a single batch. */
   blockRequestBatchSize: number;
 
-  /**
-   * DEBUG: Disable colocation penalty - for testing purposes only
-   */
+  /** DEBUG: Disable colocation penalty - for testing purposes only */
   debugDisableColocationPenalty: boolean;
 
-  /**
-   * The frequency in which to check for new peers.
-   */
+  /** The frequency in which to check for new peers. */
   peerCheckIntervalMS: number;
 
-  /**
-   * Size of queue of L2 blocks to store.
-   */
+  /** Size of queue of L2 blocks to store. */
   l2QueueSize: number;
 
-  /**
-   * The announce address for TCP.
-   */
-  tcpAnnounceAddress?: string;
-
-  /**
-   * The announce address for UDP.
-   */
-  udpAnnounceAddress?: string;
-
-  /**
-   * The listen address for TCP.
-   */
-  tcpListenAddress: string;
-
-  /**
-   * The listen address for UDP.
-   */
-  udpListenAddress: string;
-
-  /**
-   * An optional peer id private key. If blank, will generate a random key.
-   */
-  peerIdPrivateKey?: string;
-
-  /**
-   * A list of bootstrap peers to connect to.
-   */
+  /** The port for the P2P service. */
+  p2pPort: number;
+
+  /** The port to broadcast the P2P service on (included in the node's ENR). */
+  p2pBroadcastPort?: number;
+
+  /** The IP address for the P2P service. */
+  p2pIp?: string;
+
+  /** The listen address. */
+  listenAddress: string;
+
+  /** An optional peer id private key. If blank, will generate a random key. */
+  peerIdPrivateKey?: SecretValue<string>;
+
+  /** An optional path to store generated peer id private keys. If blank, will default to storing any generated keys in the data directory. */
+  peerIdPrivateKeyPath?: string;
+
+  /** A list of bootstrap peers to connect to. */
   bootstrapNodes: string[];
 
   /** Whether to execute the version check in the bootstrap node ENR. */
@@ -81,97 +67,118 @@ export interface P2PConfig extends P2PReqRespConfig, ChainConfig {
   /** Whether to consider any configured bootnodes as full peers, e.g. for transaction gossiping */
   bootstrapNodesAsFullPeers: boolean;
 
-  /**
-   * The maximum number of peers (a peer count above this will cause the node to refuse connection attempts)
-   */
+  /** The maximum number of peers (a peer count above this will cause the node to refuse connection attempts) */
   maxPeerCount: number;
 
-  /**
-   * If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.
-   */
+  /** If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false. */
   queryForIp: boolean;
 
-  /** How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven) */
-  keepProvenTxsInPoolFor: number;
-
-  /** How many slots to keep attestations for. */
-  keepAttestationsInPoolFor: number;
-
-  /**
-   * The interval of the gossipsub heartbeat to perform maintenance tasks.
-   */
+  /** The interval of the gossipsub heartbeat to perform maintenance tasks. */
   gossipsubInterval: number;
 
-  /**
-   * The D parameter for the gossipsub protocol.
-   */
+  /** The D parameter for the gossipsub protocol. */
   gossipsubD: number;
 
-  /**
-   * The Dlo parameter for the gossipsub protocol.
-   */
+  /** The Dlo parameter for the gossipsub protocol. */
   gossipsubDlo: number;
 
-  /**
-   * The Dhi parameter for the gossipsub protocol.
-   */
+  /** The Dhi parameter for the gossipsub protocol. */
   gossipsubDhi: number;
 
-  /**
-   * The Dlazy parameter for the gossipsub protocol.
-   */
+  /** The Dlazy parameter for the gossipsub protocol. */
   gossipsubDLazy: number;
 
-  /**
-   * Whether to flood publish messages. - For testing purposes only
-   */
+  /** Whether to flood publish messages. - For testing purposes only */
   gossipsubFloodPublish: boolean;
 
-  /**
-   * The number of gossipsub interval message cache windows to keep.
-   */
+  /** The number of gossipsub interval message cache windows to keep. */
   gossipsubMcacheLength: number;
 
-  /**
-   * How many message cache windows to include when gossiping with other pears.
-   */
+  /** How many message cache windows to include when gossiping with other pears. */
   gossipsubMcacheGossip: number;
 
-  /**
-   * The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it.
-   */
+  /** How long to keep message IDs in the seen cache (ms). */
+  gossipsubSeenTTL: number;
+
+  /** The 'age' (in # of L2 blocks) of a processed tx after which we heavily penalize a peer for re-sending it. */
   doubleSpendSeverePeerPenaltyWindow: number;
 
-  /**
-   * The weight of the tx topic for the gossipsub protocol.  This determines how much the score for this specific topic contributes to the overall peer score.
-   */
+  /** The weight of the tx topic for the gossipsub protocol.  This determines how much the score for this specific topic contributes to the overall peer score. */
   gossipsubTxTopicWeight: number;
 
-  /**
-   * This is the weight applied to the penalty for delivering invalid messages.
-   */
+  /** This is the weight applied to the penalty for delivering invalid messages. */
   gossipsubTxInvalidMessageDeliveriesWeight: number;
 
-  /**
-   * determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.
-   */
+  /** determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1. */
   gossipsubTxInvalidMessageDeliveriesDecay: number;
 
-  /**
-   * The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.
-   */
+  /** The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors. */
   peerPenaltyValues: number[];
 
   /** Limit of transactions to archive in the tx pool. Once the archived tx limit is reached, the oldest archived txs will be purged. */
   archivedTxLimit: number;
+
+  /** A list of trusted peers. */
+  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. */
+  txPublicSetupAllowList: AllowedElement[];
+
+  /** The maximum cumulative tx size (in bytes) of pending txs before evicting lower priority txs. */
+  maxTxPoolSize: number;
+
+  /** If the pool is full, it will still accept a few more txs until it reached maxTxPoolOverspillFactor * maxTxPoolSize. Then it will evict */
+  txPoolOverflowFactor: number;
+
+  /** The node's seen message ID cache size */
+  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;
+
+  /** Whether transactions are disabled for this node. This means transactions will be rejected at the RPC and P2P layers. */
+  disableTransactions: boolean;
+
+  /** True to simulate discarding transactions. - For testing purposes only*/
+  dropTransactions: boolean;
+
+  /** The probability that a transaction is discarded. - For testing purposes only */
+  dropTransactionsProbability: number;
+
+  /** Whether to delete transactions from the pool after a reorg instead of moving them back to pending. */
+  txPoolDeleteTxsAfterReorg: boolean;
 }
 
+export const DEFAULT_P2P_PORT = 40400;
+
 export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   p2pEnabled: {
     env: 'P2P_ENABLED',
     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.',
@@ -192,34 +199,39 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
     description: 'Size of queue of L2 blocks to store.',
     ...numberConfigHelper(1_000),
   },
-  tcpListenAddress: {
-    env: 'P2P_TCP_LISTEN_ADDR',
-    defaultValue: '0.0.0.0:40400',
-    description: 'The listen address for TCP. Format: <IP_ADDRESS>:<PORT>.',
+  listenAddress: {
+    env: 'P2P_LISTEN_ADDR',
+    defaultValue: '0.0.0.0',
+    description: 'The listen address. ipv4 address.',
   },
-  udpListenAddress: {
-    env: 'P2P_UDP_LISTEN_ADDR',
-    defaultValue: '0.0.0.0:40400',
-    description: 'The listen address for UDP. Format: <IP_ADDRESS>:<PORT>.',
+  p2pPort: {
+    env: 'P2P_PORT',
+    description: `The port for the P2P service. Defaults to ${DEFAULT_P2P_PORT}`,
+    ...numberConfigHelper(DEFAULT_P2P_PORT),
   },
-  tcpAnnounceAddress: {
-    env: 'P2P_TCP_ANNOUNCE_ADDR',
-    description:
-      'The announce address for TCP. Format: <IP_ADDRESS>:<PORT>. Leave IP_ADDRESS blank to query for public IP.',
+  p2pBroadcastPort: {
+    env: 'P2P_BROADCAST_PORT',
+    description: `The port to broadcast the P2P service on (included in the node's ENR). Defaults to P2P_PORT.`,
   },
-  udpAnnounceAddress: {
-    env: 'P2P_UDP_ANNOUNCE_ADDR',
-    description:
-      'The announce address for UDP. Format: <IP_ADDRESS>:<PORT>. Leave IP_ADDRESS blank to query for public IP.',
+  p2pIp: {
+    env: 'P2P_IP',
+    description: 'The IP address for the P2P service. ipv4 address.',
   },
   peerIdPrivateKey: {
     env: 'PEER_ID_PRIVATE_KEY',
     description: 'An optional peer id private key. If blank, will generate a random key.',
+    ...secretStringConfigHelper(),
+  },
+  peerIdPrivateKeyPath: {
+    env: 'PEER_ID_PRIVATE_KEY_PATH',
+    description:
+      'An optional path to store generated peer id private keys. If blank, will default to storing any generated keys in the root of the data directory.',
   },
   bootstrapNodes: {
     env: 'BOOTSTRAP_NODES',
     parseEnv: (val: string) => val.split(','),
     description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
+    defaultValue: [],
   },
   bootstrapNodeEnrVersionCheck: {
     env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
@@ -242,17 +254,6 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
     ...booleanConfigHelper(),
   },
-  keepProvenTxsInPoolFor: {
-    env: 'P2P_TX_POOL_KEEP_PROVEN_FOR',
-    description:
-      'How many blocks have to pass after a block is proven before its txs are deleted (zero to delete immediately once proven)',
-    ...numberConfigHelper(0),
-  },
-  keepAttestationsInPoolFor: {
-    env: 'P2P_ATTESTATION_POOL_KEEP_FOR',
-    description: 'How many slots to keep attestations for.',
-    ...numberConfigHelper(96),
-  },
   gossipsubInterval: {
     env: 'P2P_GOSSIPSUB_INTERVAL_MS',
     description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
@@ -281,7 +282,7 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   gossipsubFloodPublish: {
     env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
     description: 'Whether to flood publish messages. - For testing purposes only',
-    ...booleanConfigHelper(true),
+    ...booleanConfigHelper(false),
   },
   gossipsubMcacheLength: {
     env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
@@ -290,9 +291,14 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
   },
   gossipsubMcacheGossip: {
     env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
-    description: 'How many message cache windows to include when gossiping with other pears.',
+    description: 'How many message cache windows to include when gossiping with other peers.',
     ...numberConfigHelper(3),
   },
+  gossipsubSeenTTL: {
+    env: 'P2P_GOSSIPSUB_SEEN_TTL',
+    description: 'How long to keep message IDs in the seen cache.',
+    ...numberConfigHelper(20 * 60 * 1000),
+  },
   gossipsubTxTopicWeight: {
     env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
     description: 'The weight of the tx topic for the gossipsub protocol.',
@@ -331,8 +337,92 @@ export const p2pConfigMappings: ConfigMappingsType<P2PConfig> = {
       'The number of transactions that will be archived. If the limit is set to 0 then archiving will be disabled.',
     ...numberConfigHelper(0),
   },
+  trustedPeers: {
+    env: 'P2P_TRUSTED_PEERS',
+    parseEnv: (val: string) => val.split(','),
+    description: 'A list of trusted peer ENRs that will always be persisted. Separated by commas.',
+    defaultValue: [],
+  },
+  privatePeers: {
+    env: 'P2P_PRIVATE_PEERS',
+    parseEnv: (val: string) => val.split(','),
+    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: string) => 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: string | undefined) => (val ? +val : undefined),
+    description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.',
+  },
+  txPublicSetupAllowList: {
+    env: 'TX_PUBLIC_SETUP_ALLOWLIST',
+    parseEnv: (val: string) => parseAllowList(val),
+    description: 'The list of functions calls allowed to run in setup',
+    printDefault: () =>
+      'AuthRegistry, FeeJuice.increase_public_balance, Token.increase_public_balance, FPC.prepare_fee',
+  },
+  maxTxPoolSize: {
+    env: 'P2P_MAX_TX_POOL_SIZE',
+    description: 'The maximum cumulative tx size of pending txs (in bytes) before evicting lower priority txs.',
+    ...numberConfigHelper(100_000_000), // 100MB
+  },
+  txPoolOverflowFactor: {
+    env: 'P2P_TX_POOL_OVERFLOW_FACTOR',
+    description: 'How much the tx pool can overflow before it starts evicting txs. Must be greater than 1',
+    ...floatConfigHelper(1.1), // 10% overflow
+  },
+  seenMessageCacheSize: {
+    env: 'P2P_SEEN_MSG_CACHE_SIZE',
+    description: 'The number of messages to keep in the seen message cache',
+    ...numberConfigHelper(100_000), // 100K
+  },
+  p2pDisableStatusHandshake: {
+    env: 'P2P_DISABLE_STATUS_HANDSHAKE',
+    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),
+  },
+  disableTransactions: {
+    env: 'TRANSACTIONS_DISABLED',
+    description:
+      'Whether transactions are disabled for this node. This means transactions will be rejected at the RPC and P2P layers.',
+    ...booleanConfigHelper(false),
+  },
+  txPoolDeleteTxsAfterReorg: {
+    env: 'P2P_TX_POOL_DELETE_TXS_AFTER_REORG',
+    description: 'Whether to delete transactions from the pool after a reorg instead of moving them back to pending.',
+    ...booleanConfigHelper(false),
+  },
   ...p2pReqRespConfigMappings,
   ...chainConfigMappings,
+  ...txCollectionConfigMappings,
 };
 
 /**
@@ -350,22 +440,86 @@ export function getP2PDefaultConfig(): P2PConfig {
 /**
  * Required P2P config values for a bootstrap node.
  */
-export type BootnodeConfig = Pick<P2PConfig, 'udpAnnounceAddress' | 'peerIdPrivateKey' | 'bootstrapNodes'> &
-  Required<Pick<P2PConfig, 'udpListenAddress'>> &
-  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKB'> &
+export type BootnodeConfig = Pick<
+  P2PConfig,
+  | 'p2pIp'
+  | 'p2pPort'
+  | 'p2pBroadcastPort'
+  | 'peerIdPrivateKey'
+  | 'peerIdPrivateKeyPath'
+  | 'bootstrapNodes'
+  | 'listenAddress'
+  | 'queryForIp'
+> &
+  Required<Pick<P2PConfig, 'p2pIp' | 'p2pPort'>> &
+  Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb'> &
   Pick<ChainConfig, 'l1ChainId'>;
 
 const bootnodeConfigKeys: (keyof BootnodeConfig)[] = [
-  'udpAnnounceAddress',
+  'p2pIp',
+  'p2pPort',
+  'p2pBroadcastPort',
+  'listenAddress',
   'peerIdPrivateKey',
-  'udpListenAddress',
+  'peerIdPrivateKeyPath',
   'dataDirectory',
-  'dataStoreMapSizeKB',
+  'dataStoreMapSizeKb',
   'bootstrapNodes',
   'l1ChainId',
+  'queryForIp',
 ];
 
 export const bootnodeConfigMappings = pickConfigMappings(
   { ...p2pConfigMappings, ...dataConfigMappings, ...chainConfigMappings },
   bootnodeConfigKeys,
 );
+
+/**
+ * Parses a string to a list of allowed elements.
+ * Each encoded is expected to be of one of the following formats
+ * `I:${address}`
+ * `I:${address}:${selector}`
+ * `C:${classId}`
+ * `C:${classId}:${selector}`
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */
+export function parseAllowList(value: string): AllowedElement[] {
+  const entries: AllowedElement[] = [];
+
+  if (!value) {
+    return entries;
+  }
+
+  for (const val of value.split(',')) {
+    const [typeString, identifierString, selectorString] = val.split(':');
+    const selector = selectorString !== undefined ? FunctionSelector.fromString(selectorString) : undefined;
+
+    if (typeString === 'I') {
+      if (selector) {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          address: AztecAddress.fromString(identifierString),
+        });
+      }
+    } else if (typeString === 'C') {
+      if (selector) {
+        entries.push({
+          classId: Fr.fromHexString(identifierString),
+          selector,
+        });
+      } else {
+        entries.push({
+          classId: Fr.fromHexString(identifierString),
+        });
+      }
+    }
+  }
+
+  return entries;
+}

package/src/enr/generate-enr.ts

@@ -1,22 +1,26 @@
 import type { LogFn } from '@aztec/foundation/log';
 import { type ChainConfig, emptyChainConfig } from '@aztec/stdlib/config';
+import type { ComponentsVersions } from '@aztec/stdlib/versioning';
 
-import { ENR, SignableENR } from '@chainsafe/enr';
 import type { PeerId } from '@libp2p/interface';
-import { multiaddr } from '@multiformats/multiaddr';
+import { type Multiaddr, multiaddr } from '@multiformats/multiaddr';
+import { ENR, SignableENR } from '@nethermindeth/enr';
 
-import { AZTEC_ENR_KEY } from '../types/index.js';
+import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from '../types/index.js';
 import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
-import { setAztecEnrKey } from '../versioning.js';
+import { setAztecClientVersionEnrKey, setAztecEnrKey } from '../versioning.js';
+
+export { ENR };
 
 export async function createBootnodeENRandPeerId(
   privateKey: string,
-  udpAnnounceAddress: string,
+  p2pIp: string,
+  p2pBroadcastPort: number,
   l1ChainId: number,
 ): Promise<{ enr: SignableENR; peerId: PeerId }> {
   const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
   const enr = SignableENR.createFromPeerId(peerId);
-  const publicAddr = multiaddr(convertToMultiaddr(udpAnnounceAddress, 'udp'));
+  const publicAddr = multiaddr(convertToMultiaddr(p2pIp, p2pBroadcastPort, 'udp'));
   enr.setLocationMultiaddr(publicAddr);
 
   const config: ChainConfig = {
@@ -28,12 +32,41 @@ export async function createBootnodeENRandPeerId(
   return { enr, peerId };
 }
 
+export function createNodeENR(
+  peerId: PeerId,
+  multiAddrUdp: Multiaddr | undefined,
+  multiAddrTcp: Multiaddr | undefined,
+  chainConfig: ChainConfig,
+  packageVersion: string,
+): { enr: SignableENR; versions: ComponentsVersions } {
+  // create ENR from PeerId
+  const enr = SignableENR.createFromPeerId(peerId);
+  // Add aztec identification to ENR
+  const versions = setAztecEnrKey(enr, chainConfig);
+  // Add aztec client version to ENR
+  setAztecClientVersionEnrKey(enr, packageVersion);
+
+  // set location multiaddr in ENR record
+  if (multiAddrUdp) {
+    enr.setLocationMultiaddr(multiAddrUdp);
+  }
+  if (multiAddrTcp) {
+    enr.setLocationMultiaddr(multiAddrTcp);
+  }
+
+  return { enr, versions };
+}
+
 export async function printENR(enr: string, log: LogFn) {
   const decoded = ENR.decodeTxt(enr);
   log(`PeerID: ${await decoded.peerId()}`);
   log(`IP: ${decoded.ip}`);
   log(`UDP: ${decoded.udp}`);
   log(`TCP: ${decoded.tcp}`);
+
   const aztec = decoded.kvs.get(AZTEC_ENR_KEY);
   log(`Aztec version: ${aztec?.toString()}`);
+
+  const aztecClientVersion = decoded.kvs.get(AZTEC_ENR_CLIENT_VERSION_KEY);
+  log(`Aztec client version ${aztecClientVersion ? aztecClientVersion!.toString() : 'N/A'}`);
 }

package/src/index.ts

@@ -1,5 +1,9 @@
+export { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
+export type { PeerId } from '@libp2p/interface';
+
 export * from './bootstrap/bootstrap.js';
 export * from './client/index.js';
+export * from './enr/index.js';
 export * from './config.js';
 export * from './mem_pools/attestation_pool/index.js';
 export * from './mem_pools/tx_pool/index.js';