@aztec-labs/p2p 6.0.0-nightly.20260829

package/dest/config.js

@@ -0,0 +1,458 @@
+import { bigintConfigHelper, booleanConfigHelper, floatConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper, optionalNumberConfigHelper, percentageConfigHelper, pickConfigMappings, secretStringConfigHelper } from '@aztec-labs/foundation/config';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FunctionSelector } from '@aztec-labs/stdlib/abi/function-selector';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { chainConfigMappings, sharedSequencerConfigMappings } from '@aztec-labs/stdlib/config';
+import { dataConfigMappings } from '@aztec-labs/stdlib/kv-store';
+import { batchTxRequesterConfigMappings } from './services/reqresp/batch-tx-requester/config.js';
+import { p2pReqRespConfigMappings } from './services/reqresp/config.js';
+import { txCollectionConfigMappings } from './services/tx_collection/config.js';
+import { txFileStoreConfigMappings } from './services/tx_file_store/config.js';
+export const DEFAULT_P2P_PORT = 40400;
+/** Default endpoints used to discover this machine's public IPv4 when `queryForIp` is enabled. */ export const DEFAULT_PUBLIC_IP_SERVICES = [
+    'https://api.ipify.org/',
+    'https://checkip.amazonaws.com/',
+    'https://ifconfig.me/ip',
+    'https://icanhazip.com/'
+];
+export const p2pConfigMappings = {
+    validateMaxTxsPerBlock: {
+        env: 'VALIDATOR_MAX_TX_PER_BLOCK',
+        description: 'Maximum transactions per block for validation. Overrides maxTxsPerBlock for gossip validation when set.',
+        ...optionalNumberConfigHelper()
+    },
+    validateMaxTxsPerCheckpoint: {
+        env: 'VALIDATOR_MAX_TX_PER_CHECKPOINT',
+        description: 'Maximum transactions per checkpoint for validation. Used as fallback for maxTxsPerBlock when that is not set.',
+        ...optionalNumberConfigHelper()
+    },
+    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.',
+        ...numberConfigHelper(100)
+    },
+    debugDisableColocationPenalty: {
+        env: 'DEBUG_P2P_DISABLE_COLOCATION_PENALTY',
+        description: 'DEBUG: Disable colocation penalty - NEVER set to true in production',
+        ...booleanConfigHelper(false)
+    },
+    peerCheckIntervalMS: {
+        env: 'P2P_PEER_CHECK_INTERVAL_MS',
+        description: 'The frequency in which to check for new peers.',
+        ...numberConfigHelper(30_000)
+    },
+    peerFailedBanTimeMs: {
+        env: 'P2P_PEER_FAILED_BAN_TIME_MS',
+        description: 'How long to ban a peer after it fails maximum dial attempts.',
+        ...numberConfigHelper(5 * 60 * 1000)
+    },
+    l2QueueSize: {
+        env: 'P2P_L2_QUEUE_SIZE',
+        description: 'Size of queue of L2 blocks to store.',
+        ...numberConfigHelper(1_000)
+    },
+    listenAddress: {
+        env: 'P2P_LISTEN_ADDR',
+        defaultValue: '0.0.0.0',
+        description: 'The listen address. ipv4 address.'
+    },
+    p2pPort: {
+        env: 'P2P_PORT',
+        description: `The port for the P2P service. Defaults to ${DEFAULT_P2P_PORT}`,
+        ...numberConfigHelper(DEFAULT_P2P_PORT)
+    },
+    p2pBroadcastPort: {
+        env: 'P2P_BROADCAST_PORT',
+        description: `The port to broadcast the P2P service on (included in the node's ENR). Defaults to P2P_PORT.`
+    },
+    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)=>val.split(','),
+        description: 'A list of bootstrap peer ENRs to connect to. Separated by commas.',
+        defaultValue: []
+    },
+    bootstrapNodeEnrVersionCheck: {
+        env: 'P2P_BOOTSTRAP_NODE_ENR_VERSION_CHECK',
+        description: 'Whether to check the version of the bootstrap node ENR.',
+        ...booleanConfigHelper()
+    },
+    bootstrapNodesAsFullPeers: {
+        env: 'P2P_BOOTSTRAP_NODES_AS_FULL_PEERS',
+        description: 'Whether to consider our configured bootnodes as full peers',
+        ...booleanConfigHelper(false)
+    },
+    maxPeerCount: {
+        env: 'P2P_MAX_PEERS',
+        description: 'The maximum number of peers to connect to.',
+        ...numberConfigHelper(100)
+    },
+    p2pHealthMinPeers: {
+        env: 'P2P_HEALTH_MIN_PEERS',
+        description: 'Minimum number of connected peers for p2p to be reported as healthy on the status endpoint. Zero never fails the check.',
+        ...numberConfigHelper(0)
+    },
+    queryForIp: {
+        env: 'P2P_QUERY_FOR_IP',
+        description: 'If announceUdpAddress or announceTcpAddress are not provided, query for the IP address of the machine. Default is false.',
+        ...booleanConfigHelper()
+    },
+    publicIpServices: {
+        env: 'P2P_PUBLIC_IP_SERVICES',
+        parseEnv: (val)=>val.split(',').map((s)=>s.trim()).filter(Boolean),
+        description: 'Comma-separated HTTPS URLs that return plain-text public IPv4. Used when P2P_QUERY_FOR_IP is true and P2P_IP is unset. Tried in order until one succeeds.',
+        defaultValue: DEFAULT_PUBLIC_IP_SERVICES
+    },
+    gossipsubInterval: {
+        env: 'P2P_GOSSIPSUB_INTERVAL_MS',
+        description: 'The interval of the gossipsub heartbeat to perform maintenance tasks.',
+        ...numberConfigHelper(700)
+    },
+    gossipsubD: {
+        env: 'P2P_GOSSIPSUB_D',
+        description: 'The D parameter for the gossipsub protocol.',
+        ...numberConfigHelper(8)
+    },
+    gossipsubDlo: {
+        env: 'P2P_GOSSIPSUB_DLO',
+        description: 'The Dlo parameter for the gossipsub protocol.',
+        ...numberConfigHelper(4)
+    },
+    gossipsubDhi: {
+        env: 'P2P_GOSSIPSUB_DHI',
+        description: 'The Dhi parameter for the gossipsub protocol.',
+        ...numberConfigHelper(12)
+    },
+    gossipsubDLazy: {
+        env: 'P2P_GOSSIPSUB_DLAZY',
+        description: 'The Dlazy parameter for the gossipsub protocol.',
+        ...numberConfigHelper(8)
+    },
+    gossipsubFloodPublish: {
+        env: 'P2P_GOSSIPSUB_FLOOD_PUBLISH',
+        description: 'Whether to flood publish messages. - For testing purposes only',
+        ...booleanConfigHelper(false)
+    },
+    gossipsubMcacheLength: {
+        env: 'P2P_GOSSIPSUB_MCACHE_LENGTH',
+        description: 'The number of gossipsub interval message cache windows to keep.',
+        ...numberConfigHelper(12)
+    },
+    gossipsubMcacheGossip: {
+        env: 'P2P_GOSSIPSUB_MCACHE_GOSSIP',
+        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)
+    },
+    maxGossipClockDisparityMs: {
+        env: 'P2P_MAX_GOSSIP_CLOCK_DISPARITY_MS',
+        description: 'Maximum clock-disparity tolerance (ms) applied to both ends of proposal/attestation gossip receive windows.',
+        ...numberConfigHelper(500)
+    },
+    gossipsubTxTopicWeight: {
+        env: 'P2P_GOSSIPSUB_TX_TOPIC_WEIGHT',
+        description: 'The weight of the tx topic for the gossipsub protocol.',
+        ...floatConfigHelper(1)
+    },
+    gossipsubTxInvalidMessageDeliveriesWeight: {
+        env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_WEIGHT',
+        description: 'The weight of the tx invalid message deliveries for the gossipsub protocol.',
+        ...floatConfigHelper(-20)
+    },
+    gossipsubTxInvalidMessageDeliveriesDecay: {
+        env: 'P2P_GOSSIPSUB_TX_INVALID_MESSAGE_DELIVERIES_DECAY',
+        description: 'Determines how quickly the penalty for invalid message deliveries decays over time. Between 0 and 1.',
+        ...floatConfigHelper(0.5)
+    },
+    peerPenaltyValues: {
+        env: 'P2P_PEER_PENALTY_VALUES',
+        parseEnv: (val)=>val.split(',').map(Number),
+        description: 'The values for the peer scoring system. Passed as a comma separated list of values in order: low, mid, high tolerance errors.',
+        defaultValue: [
+            2,
+            10,
+            50
+        ]
+    },
+    peerBanDurationSeconds: {
+        env: 'P2P_PEER_BAN_DURATION_SECONDS',
+        description: 'How long (in seconds) a peer is banned for once its score drops below the ban threshold.',
+        ...numberConfigHelper(24 * 60 * 60)
+    },
+    doubleSpendSeverePeerPenaltyWindow: {
+        env: 'P2P_DOUBLE_SPEND_SEVERE_PEER_PENALTY_WINDOW',
+        description: 'The "age" (in L2 blocks) of a tx after which we heavily penalize a peer for sending it.',
+        ...numberConfigHelper(30)
+    },
+    blockRequestBatchSize: {
+        env: 'P2P_BLOCK_REQUEST_BATCH_SIZE',
+        description: 'The number of blocks to fetch in a single batch.',
+        ...numberConfigHelper(20)
+    },
+    archivedTxLimit: {
+        env: 'P2P_ARCHIVED_TX_LIMIT',
+        description: '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)=>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)=>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)=>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',
+        ...optionalNumberConfigHelper(),
+        description: 'The maximum possible size of the P2P DB in KB. Overwrites the general dataStoreMapSizeKb.'
+    },
+    txPublicSetupAllowListExtend: {
+        env: 'TX_PUBLIC_SETUP_ALLOWLIST',
+        parseEnv: (val)=>parseAllowList(val),
+        description: 'Additional entries to extend the default setup allow list. Format: I:address:selector[:flags],C:classId:selector[:flags]. Flags: os (onlySelf), rn (rejectNullMsgSender), cl=N (calldataLength), joined with +.',
+        printDefault: ()=>'Default: AuthRegistry._set_authorized, AuthRegistry.set_authorized, FeeJuice._increase_public_balance'
+    },
+    maxPendingTxCount: {
+        env: 'P2P_MAX_PENDING_TX_COUNT',
+        description: 'The maximum number of pending txs before evicting lower priority txs.',
+        // Worst case scenario: Uncompressed public/private tx is ~ 156kb
+        // This implies we are using ~156MB of memory for pending pool
+        ...numberConfigHelper(1_000)
+    },
+    seenMessageCacheSize: {
+        env: 'P2P_SEEN_MSG_CACHE_SIZE',
+        description: 'The number of messages to keep in the seen message cache',
+        ...numberConfigHelper(100_000)
+    },
+    txValidationCacheSize: {
+        env: 'P2P_TX_VALIDATION_CACHE_SIZE',
+        description: 'Maximum number of items to keep in the tx validation LRU cache.',
+        ...numberConfigHelper(5_000)
+    },
+    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)
+    },
+    dropTransactionsProbability: {
+        env: 'P2P_DROP_TX_CHANCE',
+        description: 'The probability that a transaction is discarded (0 - 1). - For testing purposes only',
+        ...percentageConfigHelper(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)
+    },
+    debugP2PInstrumentMessages: {
+        env: 'DEBUG_P2P_INSTRUMENT_MESSAGES',
+        description: 'Alters the format of p2p messages to include things like broadcast timestamp FOR TESTING ONLY',
+        ...booleanConfigHelper(false)
+    },
+    fishermanMode: {
+        env: 'FISHERMAN_MODE',
+        description: 'Whether to run in fisherman mode: validates all proposals and attestations but does not broadcast attestations or participate in consensus.',
+        ...booleanConfigHelper(false)
+    },
+    broadcastEquivocatedProposals: {
+        description: 'Broadcast block proposals even when a conflicting proposal for the same slot already exists in the pool (for testing purposes only).',
+        ...booleanConfigHelper(false)
+    },
+    skipIncomingProposals: {
+        description: 'Drop incoming block and checkpoint proposals at the libp2p dispatch layer (for testing only)',
+        ...booleanConfigHelper(false)
+    },
+    skipProposalSlotValidation: {
+        description: 'Accept proposal gossip regardless of slot timing (for testing only)',
+        ...booleanConfigHelper(false)
+    },
+    skipCheckpointProposalValidation: {
+        description: 'Skip checkpoint proposal validation and always attest, broadcasting the attestation before processing the embedded last block',
+        ...booleanConfigHelper(false)
+    },
+    minTxPoolAgeMs: {
+        env: 'P2P_MIN_TX_POOL_AGE_MS',
+        description: 'Minimum age (ms) a transaction must have been in the pool before it is eligible for block building.',
+        ...numberConfigHelper(2_000)
+    },
+    slashDataWithholdingToleranceSlots: {
+        env: 'SLASH_DATA_WITHHOLDING_TOLERANCE_SLOTS',
+        description: 'L2 slots to wait after a checkpoint slot before declaring its txs missing. Drives both the data-withholding slasher check and the missing-tx collection deadline.',
+        ...numberConfigHelper(3)
+    },
+    p2pMissingTxCollectionDeadlineSlots: {
+        env: 'P2P_MISSING_TX_COLLECTION_DEADLINE_SLOTS',
+        description: 'Optional deadline (in L2 slots after the block slot) for collecting missing txs for unproven mined blocks. Clamped up to the data-withholding tolerance window so collection never gives up before the slash verdict.',
+        ...optionalNumberConfigHelper()
+    },
+    priceBumpPercentage: {
+        env: 'P2P_RPC_PRICE_BUMP_PERCENTAGE',
+        description: 'Minimum percentage fee increase required to replace an existing tx via RPC. Even at 0%, replacement still requires paying at least 1 unit more.',
+        ...bigintConfigHelper(10n)
+    },
+    keepFinalizedTxsForSlots: {
+        env: 'P2P_KEEP_FINALIZED_TXS_FOR_SLOTS',
+        description: 'Number of slots behind the finalized tip to keep finalized txs for before deleting them. 0 deletes at the finalized tip.',
+        ...numberConfigHelper(0)
+    },
+    ...pickConfigMappings(sharedSequencerConfigMappings, [
+        'expectedBlockProposalsPerSlot',
+        'maxTxsPerBlock',
+        'checkpointProposalSyncGraceSeconds',
+        'maxBlocksPerCheckpoint',
+        'blockDurationMs'
+    ]),
+    ...p2pReqRespConfigMappings,
+    ...batchTxRequesterConfigMappings,
+    ...chainConfigMappings,
+    ...txCollectionConfigMappings,
+    ...txFileStoreConfigMappings
+};
+/**
+ * Gets the config values for p2p client from environment variables.
+ * @returns The config values for p2p client.
+ */ export function getP2PConfigFromEnv() {
+    return getConfigFromMappings(p2pConfigMappings);
+}
+export function getP2PDefaultConfig() {
+    return getDefaultConfig(p2pConfigMappings);
+}
+const bootnodeConfigKeys = [
+    'p2pIp',
+    'p2pPort',
+    'p2pBroadcastPort',
+    'listenAddress',
+    'peerIdPrivateKey',
+    'peerIdPrivateKeyPath',
+    'dataDirectory',
+    'dataStoreMapSizeKb',
+    'bootstrapNodes',
+    'l1ChainId',
+    'queryForIp',
+    'publicIpServices'
+];
+export const bootnodeConfigMappings = pickConfigMappings({
+    ...p2pConfigMappings,
+    ...dataConfigMappings,
+    ...chainConfigMappings
+}, bootnodeConfigKeys);
+/**
+ * Parses a `+`-separated flags string into validation properties for an allow list entry.
+ * Supported flags: `os` (onlySelf), `rn` (rejectNullMsgSender), `cl=N` (calldataLength).
+ */ function parseFlags(flags, entry) {
+    const result = {};
+    for (const flag of flags.split('+')){
+        if (flag === 'os') {
+            result.onlySelf = true;
+        } else if (flag === 'rn') {
+            result.rejectNullMsgSender = true;
+        } else if (flag.startsWith('cl=')) {
+            const n = parseInt(flag.slice(3), 10);
+            if (isNaN(n) || n < 0) {
+                throw new Error(`Invalid allow list entry "${entry}": invalid calldataLength in flag "${flag}". Expected a non-negative integer.`);
+            }
+            result.calldataLength = n;
+        } else {
+            throw new Error(`Invalid allow list entry "${entry}": unknown flag "${flag}". Supported flags: os, rn, cl=N.`);
+        }
+    }
+    return result;
+}
+/**
+ * Parses a string to a list of allowed elements.
+ * Each entry is expected to be of one of the following formats:
+ * `I:${address}:${selector}` — instance (contract address) with function selector
+ * `C:${classId}:${selector}` — class with function selector
+ *
+ * An optional flags segment can be appended after the selector:
+ * `I:${address}:${selector}:${flags}` or `C:${classId}:${selector}:${flags}`
+ * where flags is a `+`-separated list of: `os` (onlySelf), `rn` (rejectNullMsgSender), `cl=N` (calldataLength).
+ *
+ * @param value The string to parse
+ * @returns A list of allowed elements
+ */ export function parseAllowList(value) {
+    const entries = [];
+    if (!value) {
+        return entries;
+    }
+    for (const val of value.split(',')){
+        const trimmed = val.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const [typeString, identifierString, selectorString, flagsString] = trimmed.split(':');
+        if (!selectorString) {
+            throw new Error(`Invalid allow list entry "${trimmed}": selector is required. Expected format: I:address:selector or C:classId:selector`);
+        }
+        const selector = FunctionSelector.fromString(selectorString);
+        const flags = flagsString ? parseFlags(flagsString, trimmed) : {};
+        if (typeString === 'I') {
+            entries.push({
+                address: AztecAddress.fromStringUnsafe(identifierString),
+                selector,
+                ...flags
+            });
+        } else if (typeString === 'C') {
+            entries.push({
+                classId: Fr.fromHexString(identifierString),
+                selector,
+                ...flags
+            });
+        } else {
+            throw new Error(`Invalid allow list entry "${trimmed}": unknown type "${typeString}". Expected "I" (instance) or "C" (class).`);
+        }
+    }
+    return entries;
+}

package/dest/enr/generate-enr.d.ts

@@ -0,0 +1,17 @@
+import type { LogFn } from '@aztec-labs/foundation/log';
+import { type ChainConfig } from '@aztec-labs/stdlib/config';
+import type { ComponentsVersions } from '@aztec-labs/stdlib/versioning';
+import type { PeerId } from '@libp2p/interface';
+import { type Multiaddr } from '@multiformats/multiaddr';
+import { ENR, SignableENR } from '@nethermindeth/enr';
+export { ENR };
+export declare function createBootnodeENRandPeerId(privateKey: string, p2pIp: string, p2pBroadcastPort: number, l1ChainId: number): Promise<{
+    enr: SignableENR;
+    peerId: PeerId;
+}>;
+export declare function createNodeENR(peerId: PeerId, multiAddrUdp: Multiaddr | undefined, multiAddrTcp: Multiaddr | undefined, chainConfig: ChainConfig, packageVersion: string): {
+    enr: SignableENR;
+    versions: ComponentsVersions;
+};
+export declare function printENR(enr: string, log: LogFn): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdGUtZW5yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW5yL2dlbmVyYXRlLWVuci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxLQUFLLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN4RCxPQUFPLEVBQUUsS0FBSyxXQUFXLEVBQW9CLE1BQU0sMkJBQTJCLENBQUM7QUFDL0UsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNoRCxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWEsTUFBTSx5QkFBeUIsQ0FBQztBQUNwRSxPQUFPLEVBQUUsR0FBRyxFQUFFLFdBQVcsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBTXRELE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQztBQUVmLHdCQUFzQiwwQkFBMEIsQ0FDOUMsVUFBVSxFQUFFLE1BQU0sRUFDbEIsS0FBSyxFQUFFLE1BQU0sRUFDYixnQkFBZ0IsRUFBRSxNQUFNLEVBQ3hCLFNBQVMsRUFBRSxNQUFNLEdBQ2hCLE9BQU8sQ0FBQztJQUFFLEdBQUcsRUFBRSxXQUFXLENBQUM7SUFBQyxNQUFNLEVBQUUsTUFBTSxDQUFBO0NBQUUsQ0FBQyxDQWEvQztBQUVELHdCQUFnQixhQUFhLENBQzNCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsWUFBWSxFQUFFLFNBQVMsR0FBRyxTQUFTLEVBQ25DLFlBQVksRUFBRSxTQUFTLEdBQUcsU0FBUyxFQUNuQyxXQUFXLEVBQUUsV0FBVyxFQUN4QixjQUFjLEVBQUUsTUFBTSxHQUNyQjtJQUFFLEdBQUcsRUFBRSxXQUFXLENBQUM7SUFBQyxRQUFRLEVBQUUsa0JBQWtCLENBQUE7Q0FBRSxDQWlCcEQ7QUFFRCx3QkFBc0IsUUFBUSxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLEtBQUssaUJBWXJEIn0=

package/dest/enr/generate-enr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-enr.d.ts","sourceRoot":"","sources":["../../src/enr/generate-enr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,KAAK,WAAW,EAAoB,MAAM,2BAA2B,CAAC;AAC/E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAMtD,OAAO,EAAE,GAAG,EAAE,CAAC;AAEf,wBAAsB,0BAA0B,CAC9C,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAa/C;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,GACrB;IAAE,GAAG,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAiBpD;AAED,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,iBAYrD"}

package/dest/enr/generate-enr.js

@@ -0,0 +1,52 @@
+import { emptyChainConfig } from '@aztec-labs/stdlib/config';
+import { multiaddr } from '@multiformats/multiaddr';
+import { ENR, SignableENR } from '@nethermindeth/enr';
+import { AZTEC_ENR_CLIENT_VERSION_KEY, AZTEC_ENR_KEY } from '../types/index.js';
+import { convertToMultiaddr, createLibP2PPeerIdFromPrivateKey } from '../util.js';
+import { setAztecClientVersionEnrKey, setAztecEnrKey } from '../versioning.js';
+export { ENR };
+export async function createBootnodeENRandPeerId(privateKey, p2pIp, p2pBroadcastPort, l1ChainId) {
+    const peerId = await createLibP2PPeerIdFromPrivateKey(privateKey);
+    const enr = SignableENR.createFromPeerId(peerId);
+    const publicAddr = multiaddr(convertToMultiaddr(p2pIp, p2pBroadcastPort, 'udp'));
+    enr.setLocationMultiaddr(publicAddr);
+    const config = {
+        ...emptyChainConfig,
+        l1ChainId
+    };
+    setAztecEnrKey(enr, config);
+    return {
+        enr,
+        peerId
+    };
+}
+export function createNodeENR(peerId, multiAddrUdp, multiAddrTcp, chainConfig, packageVersion) {
+    // 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, log) {
+    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/dest/enr/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generate-enr.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbnIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQkFBbUIsQ0FBQyJ9

package/dest/enr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/enr/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dest/enr/index.js

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

package/dest/errors/attestation-pool.error.d.ts

@@ -0,0 +1,7 @@
+export declare class AttestationPoolError extends Error {
+    constructor(message?: string);
+}
+export declare class ProposalSlotCapExceededError extends AttestationPoolError {
+    constructor(message?: string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb24tcG9vbC5lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy9hdHRlc3RhdGlvbi1wb29sLmVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHFCQUFhLG9CQUFxQixTQUFRLEtBQUs7SUFDN0MsWUFBWSxPQUFPLENBQUMsRUFBRSxNQUFNLEVBRzNCO0NBQ0Y7QUFFRCxxQkFBYSw0QkFBNkIsU0FBUSxvQkFBb0I7SUFDcEUsWUFBWSxPQUFPLENBQUMsRUFBRSxNQUFNLEVBRzNCO0NBQ0YifQ==

package/dest/errors/attestation-pool.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attestation-pool.error.d.ts","sourceRoot":"","sources":["../../src/errors/attestation-pool.error.ts"],"names":[],"mappings":"AAAA,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAO,CAAC,EAAE,MAAM,EAG3B;CACF;AAED,qBAAa,4BAA6B,SAAQ,oBAAoB;IACpE,YAAY,OAAO,CAAC,EAAE,MAAM,EAG3B;CACF"}

package/dest/errors/attestation-pool.error.js

@@ -0,0 +1,12 @@
+export class AttestationPoolError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'AttestationPoolError';
+    }
+}
+export class ProposalSlotCapExceededError extends AttestationPoolError {
+    constructor(message){
+        super(message);
+        this.name = 'ProposalSlotCapExceededError';
+    }
+}

package/dest/errors/p2p-service.error.d.ts

@@ -0,0 +1,9 @@
+/** Checkpoint Proposal Received Callback Not Registered Error
+ *
+ * Error triggered if the allNodesCheckpointReceivedCallback is not registered
+ * @category Errors
+ */
+export declare class CheckpointProposalReceivedCallbackNotRegisteredError extends Error {
+    constructor();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicDJwLXNlcnZpY2UuZXJyb3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lcnJvcnMvcDJwLXNlcnZpY2UuZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILHFCQUFhLG9EQUFxRCxTQUFRLEtBQUs7SUFDN0UsY0FHQztDQUNGIn0=

package/dest/errors/p2p-service.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"p2p-service.error.d.ts","sourceRoot":"","sources":["../../src/errors/p2p-service.error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,oDAAqD,SAAQ,KAAK;IAC7E,cAGC;CACF"}

package/dest/errors/p2p-service.error.js

@@ -0,0 +1,10 @@
+/** Checkpoint Proposal Received Callback Not Registered Error
+ *
+ * Error triggered if the allNodesCheckpointReceivedCallback is not registered
+ * @category Errors
+ */ export class CheckpointProposalReceivedCallbackNotRegisteredError extends Error {
+    constructor(){
+        super('FATAL (allNodesCheckpointReceivedCallback): All nodes should register a checkpoint proposal handler');
+        this.name = 'CheckpointProposalReceivedCallbackNotRegisteredError';
+    }
+}

package/dest/errors/reqresp.error.d.ts

@@ -0,0 +1,21 @@
+/** Individual request timeout error
+ *
+ * This error will be thrown when a request to a specific peer times out.
+ * @category Errors
+ */
+export declare class IndividualReqRespTimeoutError extends Error {
+    constructor();
+}
+/** Oversized reqresp request error
+ *
+ * Thrown locally (before dialing) when a request payload does not fit in a single muxer frame. Such a request would
+ * reach the responder split across multiple chunks, which are never reassembled into one request.
+ * @category Errors
+ */
+export declare class OversizedReqRespRequestError extends Error {
+    readonly subProtocol: string;
+    readonly payloadSizeBytes: number;
+    readonly maxSizeBytes: number;
+    constructor(subProtocol: string, payloadSizeBytes: number, maxSizeBytes: number);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxcmVzcC5lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy9yZXFyZXNwLmVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxxQkFBYSw2QkFBOEIsU0FBUSxLQUFLO0lBQ3RELGNBRUM7Q0FDRjtBQUVEOzs7OztHQUtHO0FBQ0gscUJBQWEsNEJBQTZCLFNBQVEsS0FBSzthQUVuQyxXQUFXLEVBQUUsTUFBTTthQUNuQixnQkFBZ0IsRUFBRSxNQUFNO2FBQ3hCLFlBQVksRUFBRSxNQUFNO0lBSHRDLFlBQ2tCLFdBQVcsRUFBRSxNQUFNLEVBQ25CLGdCQUFnQixFQUFFLE1BQU0sRUFDeEIsWUFBWSxFQUFFLE1BQU0sRUFNckM7Q0FDRiJ9

package/dest/errors/reqresp.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reqresp.error.d.ts","sourceRoot":"","sources":["../../src/errors/reqresp.error.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,cAEC;CACF;AAED;;;;;GAKG;AACH,qBAAa,4BAA6B,SAAQ,KAAK;aAEnC,WAAW,EAAE,MAAM;aACnB,gBAAgB,EAAE,MAAM;aACxB,YAAY,EAAE,MAAM;IAHtC,YACkB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,YAAY,EAAE,MAAM,EAMrC;CACF"}

package/dest/errors/reqresp.error.js

@@ -0,0 +1,23 @@
+/** Individual request timeout error
+ *
+ * This error will be thrown when a request to a specific peer times out.
+ * @category Errors
+ */ export class IndividualReqRespTimeoutError extends Error {
+    constructor(){
+        super(`Request to peer timed out`);
+    }
+}
+/** Oversized reqresp request error
+ *
+ * Thrown locally (before dialing) when a request payload does not fit in a single muxer frame. Such a request would
+ * reach the responder split across multiple chunks, which are never reassembled into one request.
+ * @category Errors
+ */ export class OversizedReqRespRequestError extends Error {
+    subProtocol;
+    payloadSizeBytes;
+    maxSizeBytes;
+    constructor(subProtocol, payloadSizeBytes, maxSizeBytes){
+        super(`Request payload of ${payloadSizeBytes} bytes for ${subProtocol} exceeds the ${maxSizeBytes} byte limit of a single muxer frame`), this.subProtocol = subProtocol, this.payloadSizeBytes = payloadSizeBytes, this.maxSizeBytes = maxSizeBytes;
+        this.name = 'OversizedReqRespRequestError';
+    }
+}

package/dest/errors/tx-pool.error.d.ts

@@ -0,0 +1,8 @@
+import type { TxPoolRejectionError } from '../mem_pools/tx_pool_v2/eviction/interfaces.js';
+/** Error thrown when a transaction is not added to the mempool. */
+export declare class TxPoolError extends Error {
+    readonly reason: TxPoolRejectionError;
+    readonly data: TxPoolRejectionError;
+    constructor(reason: TxPoolRejectionError);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHgtcG9vbC5lcnJvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy90eC1wb29sLmVycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sZ0RBQWdELENBQUM7QUFFM0YsbUVBQW1FO0FBQ25FLHFCQUFhLFdBQVksU0FBUSxLQUFLO2FBR1IsTUFBTSxFQUFFLG9CQUFvQjtJQUZ4RCxTQUFnQixJQUFJLEVBQUUsb0JBQW9CLENBQUM7SUFFM0MsWUFBNEIsTUFBTSxFQUFFLG9CQUFvQixFQUl2RDtDQUNGIn0=

package/dest/errors/tx-pool.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx-pool.error.d.ts","sourceRoot":"","sources":["../../src/errors/tx-pool.error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gDAAgD,CAAC;AAE3F,mEAAmE;AACnE,qBAAa,WAAY,SAAQ,KAAK;aAGR,MAAM,EAAE,oBAAoB;IAFxD,SAAgB,IAAI,EAAE,oBAAoB,CAAC;IAE3C,YAA4B,MAAM,EAAE,oBAAoB,EAIvD;CACF"}