@steve02081504/fount-p2p 0.0.35 → 0.0.37

package/federation/entity_key_chain.mjs

@@ -5,7 +5,7 @@ import { Buffer } from 'node:buffer'
 
 import { canonicalStringify } from '../core/canonical_json.mjs'
 import { hashFromPubKeyHex } from '../core/entity_id.mjs'
-import { isHex64, normalizeHex64 } from '../core/hexIds.mjs'
+import { isHex64 } from '../core/hexIds.mjs'
 
 /**
  * entity 密钥撤销签名的域分隔前缀。
@@ -28,9 +28,10 @@ export const ENTITY_KEY_REVOKE_DOMAIN = 'fount-entity-key-revoke'
  * @returns {EntityKeyHistoryEntry[]} 创世链
  */
 export function createGenesisKeyHistory(activePubKeyHex, validFrom = Date.now()) {
+	if (!activePubKeyHex) return []
 	return [{
 		generation: 0,
-		activePubKeyHex: normalizeHex64(activePubKeyHex),
+		activePubKeyHex,
 		attestedBy: 'recovery',
 		validFrom,
 	}]
@@ -63,8 +64,8 @@ export function isActiveGenerationRevoked(keyHistory, generation) {
  * @returns {boolean} sender 是否为未吊销的活跃钥
  */
 export function isValidActiveSender(keyHistory, senderPubKeyHash) {
-	const sender = normalizeHex64(senderPubKeyHash)
-	if (!isHex64(sender)) return false
+	const sender = isHex64(senderPubKeyHash)
+	if (!sender) return false
 	for (const entry of keyHistory || []) {
 		if (isActiveGenerationRevoked(keyHistory, entry.generation)) continue
 		if (hashFromPubKeyHex(entry.activePubKeyHex) === sender)
@@ -79,7 +80,7 @@ export function isValidActiveSender(keyHistory, senderPubKeyHash) {
  * @returns {boolean} 是否为 recovery 钥签名
  */
 export function isRecoverySender(recoveryPubKeyHex, senderPubKeyHash) {
-	return hashFromPubKeyHex(recoveryPubKeyHex) === normalizeHex64(senderPubKeyHash)
+	return hashFromPubKeyHex(recoveryPubKeyHex) === senderPubKeyHash
 }
 
 /**
@@ -89,8 +90,8 @@ export function isRecoverySender(recoveryPubKeyHex, senderPubKeyHash) {
  */
 export function reduceEntityKeyRotate(state, event) {
 	const generation = Number(event.content?.generation)
-	const activePubKeyHex = normalizeHex64(event.content?.activePubKeyHex || '')
-	if (!Number.isFinite(generation) || generation < 0 || !isHex64(activePubKeyHex))
+	const activePubKeyHex = isHex64(event.content?.activePubKeyHex || '')
+	if (!Number.isFinite(generation) || generation < 0 || !activePubKeyHex)
 		return state
 	state.entityKeyHistory = state.entityKeyHistory || []
 	if (state.entityKeyHistory.some(row => row.generation === generation))
@@ -111,7 +112,7 @@ export function reduceEntityKeyRotate(state, event) {
  */
 export function reduceEntityKeyRevoke(state, event) {
 	const newGeneration = Number(event.content?.newGeneration)
-	const activePubKeyHex = normalizeHex64(event.content?.activePubKeyHex || '')
+	const activePubKeyHex = event.content?.activePubKeyHex
 	const revokeGenerations = (event.content?.revokeGenerations || [])
 		.map(Number).filter(Number.isFinite)
 	if (!Number.isFinite(newGeneration) || newGeneration < 0 || !isHex64(activePubKeyHex))
@@ -163,7 +164,7 @@ export function entityKeyRevokeSignBytes(revokeBody) {
 	const body = {
 		revokeGenerations: (revokeBody.revokeGenerations || []).map(Number),
 		newGeneration: Number(revokeBody.newGeneration),
-		activePubKeyHex: normalizeHex64(revokeBody.activePubKeyHex || ''),
+		activePubKeyHex: revokeBody.activePubKeyHex || '',
 		entityHash: String(revokeBody.entityHash || ''),
 	}
 	return Buffer.from(`${ENTITY_KEY_REVOKE_DOMAIN}\0${canonicalStringify(body)}`, 'utf8')

package/federation/message_rate_limit.mjs

@@ -1,8 +1,6 @@
 /**
  * 群级消息限速纯函数（无 I/O，供单测与 governance 复用）。
  */
-import { normalizeHex64 } from '../core/hexIds.mjs'
-
 /**
  * @param {object} event DAG 事件
  * @returns {string} 限速实体键
@@ -10,7 +8,7 @@ import { normalizeHex64 } from '../core/hexIds.mjs'
 export function messageRateEntityKey(event) {
 	const charId = String(event?.charId || '')
 	if (charId) return `char:${charId}`
-	return normalizeHex64(event?.sender)
+	return event?.sender || ''
 }
 
 /**

package/files/manifest/fetch.mjs

@@ -71,12 +71,10 @@ export async function fetchPublicManifest(context) {
 	if (!shared) return hasLocalPublic ? local : null
 
 	if (hasLocalPublic) {
-		if (wantCache) 
-			void shared.then(async result => {
-				if (result && shouldPreferIncomingPublicManifest(local, result))
-					await cachePublicManifest(ownerEntityHash, logicalPath, result)
-			})
-		
+		if (wantCache) void shared.then(async result => {
+			if (result && shouldPreferIncomingPublicManifest(local, result))
+				await cachePublicManifest(ownerEntityHash, logicalPath, result)
+		})
 		return local
 	}
 

package/files/manifest/normalize.mjs

@@ -40,8 +40,8 @@ const TRANSFER_TYPES = new Set(['public', 'file-master-key-wrap', 'vault-wrap',
  */
 export function normalizeFileManifest(input) {
 	if (!input || typeof input !== 'object') return null
-	const ownerEntityHash = String(input.ownerEntityHash || '')
-	if (!isEntityHash128(ownerEntityHash)) return null
+	const ownerEntityHash = isEntityHash128(input.ownerEntityHash)
+	if (!ownerEntityHash) return null
 	const logicalPath = String(input.logicalPath || '').replace(/^\/+/, '').replace(/\\/g, '/')
 	if (!logicalPath) return null
 	const ceMode = String(input.ceMode || 'convergent')

package/files/manifest/public.mjs

@@ -3,7 +3,7 @@ import { Buffer } from 'node:buffer'
 import { canonicalStringify } from '../../core/canonical_json.mjs'
 import { hashFromPubKeyHex, parseEntityHash } from '../../core/entity_id.mjs'
 import { assertSafeEvfsLogicalPath } from '../../core/evfs_logical_path.mjs'
-import { isHex64, isSignatureHex128, normalizeHex64 } from '../../core/hexIds.mjs'
+import { isHex64, isSignatureHex128 } from '../../core/hexIds.mjs'
 import { sign, verify } from '../../crypto/crypto.mjs'
 import { putFileManifest, saveFileManifest } from '../evfs.mjs'
 
@@ -39,7 +39,7 @@ export function publicManifestSignBytes(fields) {
  * @returns {Promise<import('./normalize.mjs').FileManifest>} 带 publicSig 的清单
  */
 export async function attachPublicManifestSig(manifest, publishedAt, entitySecretKey, entityPubKeyHex) {
-	const pubKeyHex = normalizeHex64(entityPubKeyHex)
+	const pubKeyHex = entityPubKeyHex
 	const message = publicManifestSignBytes({
 		ownerEntityHash: manifest.ownerEntityHash,
 		logicalPath: manifest.logicalPath,
@@ -73,9 +73,9 @@ export async function verifySignedPublicManifest(input) {
 	const publicSig = input?.meta?.publicSig
 	if (!publicSig || typeof publicSig !== 'object') return null
 	const publishedAt = Number(publicSig.publishedAt) || 0
-	const pubKeyHex = normalizeHex64(publicSig.pubKeyHex)
-	const sigHex = String(publicSig.sigHex || '')
-	if (!isHex64(pubKeyHex) || !isSignatureHex128(sigHex) || publishedAt <= 0) return null
+	const pubKeyHex = isHex64(publicSig.pubKeyHex)
+	const sigHex = isSignatureHex128(publicSig.sigHex)
+	if (!pubKeyHex || !sigHex || publishedAt <= 0) return null
 
 	const parsed = parseEntityHash(manifest.ownerEntityHash)
 	if (!parsed) return null

package/governance/branch.mjs

@@ -1,4 +1,3 @@
-import { normalizeHex64 } from '../core/hexIds.mjs'
 import { sortedPrevEventIds } from '../dag/index.mjs'
 import { getGovernanceAuthzTypes } from '../registries/event_type.mjs'
 
@@ -105,7 +104,7 @@ function governanceAuthzScoreForTip(tipId, byId, reputationBySender) {
 	for (const eventId of ancestorClosureFromTip(tipId, byId)) {
 		const event = byId.get(eventId)
 		if (!event || !getGovernanceAuthzTypes().has(event.type)) continue
-		const sender = normalizeHex64(event.sender)
+		const { sender } = event
 		if (sender) score += Number(reputationBySender[sender] ?? 0)
 	}
 	return score

package/governance/join_pow.mjs

@@ -3,8 +3,6 @@
  */
 import { createHash } from 'node:crypto'
 
-import { normalizeHex64 } from '../core/hexIds.mjs'
-
 import admissionTunables from './tunables.json' with { type: 'json' }
 
 /** 默认 epoch 窗口（1 小时） */
@@ -105,8 +103,8 @@ export function verifyJoinPow(powSolution, options) {
 	const anchorRef = String(powSolution.anchorRef ?? '')
 	const { nonce } = powSolution
 	const epoch = Number(powSolution.epoch)
-	const joinerNodeHash = normalizeHex64(powSolution.joinerNodeHash ?? options.senderNodeHash)
-	const senderNodeHash = normalizeHex64(options.senderNodeHash)
+	const { senderNodeHash } = options
+	const joinerNodeHash = powSolution.joinerNodeHash ?? senderNodeHash
 
 	if (!anchorRef || nonce == null || !Number.isFinite(epoch)) return { ok: false, achievedBits: 0 }
 	if (!joinerNodeHash || joinerNodeHash !== senderNodeHash) return { ok: false, achievedBits: 0 }

package/governance/owner_succession_ballot.mjs

@@ -4,7 +4,7 @@
 import { Buffer } from 'node:buffer'
 
 import { canonicalStringify } from '../core/canonical_json.mjs'
-import { isHex64, isSignatureHex128, normalizeHex64 } from '../core/hexIds.mjs'
+import { isHex64, isSignatureHex128 } from '../core/hexIds.mjs'
 import { pubKeyHash, verify } from '../crypto/crypto.mjs'
 
 const BALLOT_DOMAIN = 'fount-owner-succession'
@@ -15,7 +15,7 @@ const BALLOT_DOMAIN = 'fount-owner-succession'
  */
 export function ownerSuccessionBallotSignBytes(ballot) {
 	const body = {
-		proposedOwnerPubKeyHash: normalizeHex64(ballot.proposedOwnerPubKeyHash),
+		proposedOwnerPubKeyHash: ballot.proposedOwnerPubKeyHash,
 		groupId: ballot.groupId,
 		ballotId: ballot.ballotId,
 	}
@@ -42,9 +42,9 @@ export async function verifyOwnerSuccessionThreshold(ballot, adminPubKeyHashes,
 	let valid = 0
 
 	for (const entry of ballot.adminSignatures || []) {
-		const pubKeyHex = normalizeHex64(entry.pubKeyHex)
-		const signatureHex = entry.signature
-		if (!isHex64(pubKeyHex) || !isSignatureHex128(signatureHex)) continue
+		const pubKeyHex = isHex64(entry.pubKeyHex)
+		const signatureHex = isSignatureHex128(entry.signature)
+		if (!pubKeyHex || !signatureHex) continue
 
 		const hash = pubKeyHash(Buffer.from(pubKeyHex, 'hex'))
 		if (!admins.has(hash) || seen.has(hash)) continue

package/index.mjs

@@ -2,6 +2,7 @@
  * Federation P2P 门面：fount 网络引导与房间/发现入口。
  */
 import { registerDiscoveryProvider } from './discovery/index.mjs'
+import { getNodePopulationEstimate } from './discovery/nostr/census.mjs'
 import {
 	isInfraRunning,
 	setInfraPriority,
@@ -13,9 +14,11 @@ import { ensureNodeDefaults, getNodeHash } from './node/identity.mjs'
 import {
 	closeNode,
 	getNodeDir,
+	getP2PFeatures,
 	initNode,
 	isNodeInitialized,
 	setNodeLogger,
+	setP2PFeatures,
 	setSignalingRuntimeConfig,
 } from './node/instance.mjs'
 import { setConnectivityDebug } from './node/log.mjs'
@@ -73,6 +76,8 @@ export {
 	getLinkRegistry,
 	getNodeDir,
 	getNodeHash,
+	getNodePopulationEstimate,
+	getP2PFeatures,
 	getPeerHealth,
 	getReputationExportAllowlist,
 	getReputationLocks,
@@ -94,6 +99,7 @@ export {
 	setConnectivityDebug,
 	setInfraPriority,
 	setNodeLogger,
+	setP2PFeatures,
 	setReputationExportAllowlist,
 	setReputationTable,
 	setRoutingProfile,
@@ -105,20 +111,21 @@ export {
 }
 
 /**
- * @param {{ nodeDir?: string, entityStore?: import('./node/entity_store.mjs').EntityStore, logger?: object | null, signaling?: import('./node/signaling_config.mjs').SignalingRuntimeConfig }} [options] - 首次 init 时的节点选项
+ * @param {{ nodeDir?: string, entityStore?: import('./node/entity_store.mjs').EntityStore, logger?: object | null, signaling?: import('./node/signaling_config.mjs').SignalingRuntimeConfig, features?: Record<string, boolean> }} [options] - 首次 init 时的节点选项
  * @returns {Promise<void>}
  */
 export async function startNode(options = {}) {
 	if (!isNodeInitialized()) {
-		const { nodeDir, entityStore, logger, signaling, ...rest } = options
+		const { nodeDir, entityStore, logger, signaling, features, ...rest } = options
 		if (Object.keys(rest).length)
 			throw new Error('p2p: startNode unknown options')
 		initNode({ nodeDir, entityStore })
 		if (logger !== undefined) setNodeLogger(logger)
 		if (signaling !== undefined) setSignalingRuntimeConfig(signaling)
+		if (features !== undefined) setP2PFeatures(features)
 	}
-	else if (options?.nodeDir || options?.entityStore || options?.logger !== undefined || options?.signaling)
-		throw new Error('p2p: startNode options ignored after initNode — use setNodeLogger / setSignalingRuntimeConfig')
+	else if (options?.nodeDir || options?.entityStore || options?.logger !== undefined || options?.signaling || options?.features)
+		throw new Error('p2p: startNode options ignored after initNode — use setNodeLogger / setSignalingRuntimeConfig / setP2PFeatures')
 
 	ensureNodeDefaults()
 	await getLinkRegistry().ensureRuntime()

package/infra/priority.mjs

@@ -1,4 +1,3 @@
-import { normalizeHex64 } from '../core/hexIds.mjs'
 import { loadReputation } from '../node/reputation_store.mjs'
 import { pickNodeScoreFromReputation } from '../reputation/pick_score.mjs'
 import { getLinkRegistry } from '../transport/link_registry.mjs'
@@ -38,7 +37,7 @@ export function applyPriorityToRegistry() {
 	registry.setPriorityWeightFunction(nodeHash => {
 		const score = pickNodeScoreFromReputation(
 			loadReputation(),
-			normalizeHex64(nodeHash) || nodeHash,
+			nodeHash,
 		)
 		return Math.floor(score * PRIORITY_BOOST)
 	})

package/link/handshake.mjs

@@ -1,11 +1,14 @@
 import { Buffer } from 'node:buffer'
 import { randomBytes } from 'node:crypto'
 
-import { isHex64, isSignatureHex128, normalizeHex64 } from '../core/hexIds.mjs'
+import { isHex64, isSignatureHex128 } from '../core/hexIds.mjs'
 import { normalizeTcpPort } from '../core/tcp_port.mjs'
 import { keyPairFromSeed, pubKeyHash, sign, verify } from '../crypto/crypto.mjs'
 import { normalizeLanHosts } from '../discovery/lan_interfaces.mjs'
+import { MAX_ADVERT_LISTEN_RELAYS, MAX_ADVERT_RELAY_POOL, MAX_RTT_MS } from '../discovery/nostr/constants.mjs'
+import { normalizeNostrRelayUrl } from '../discovery/nostr/relays.mjs'
 import { ensureNodeSeed, getNodeHash } from '../node/identity.mjs'
+import { nodeDebug } from '../node/log.mjs'
 
 import { normalizeDtlsFingerprint } from './sdp_fingerprint.mjs'
 
@@ -20,9 +23,7 @@ export const LINK_HANDSHAKE_DOMAIN = 'fount-link'
  * @returns {string | null} 规范化 binding，无效时 null
  */
 export function normalizeLinkBinding(value) {
-	const dtls = normalizeDtlsFingerprint(value)
-	if (dtls) return dtls
-	return isHex64(value)
+	return normalizeDtlsFingerprint(value) || isHex64(value)
 }
 
 /**
@@ -33,16 +34,14 @@ export function normalizeLinkBinding(value) {
  * @returns {Uint8Array} 待签名消息字节
  */
 export function buildAuthMessage(peerNonce, localBinding, localNodeHash) {
-	const nonce = normalizeHex64(peerNonce)
 	const binding = normalizeLinkBinding(localBinding)
-	const nodeHash = normalizeHex64(localNodeHash)
-	if (!/^[\da-f]{64}$/u.test(nonce))
+	if (!/^[\da-f]{64}$/u.test(peerNonce))
 		throw new Error('p2p: auth nonce must be 64 hex characters')
 	if (!binding)
 		throw new Error('p2p: link binding missing or invalid')
-	if (!isHex64(nodeHash))
+	if (!isHex64(localNodeHash))
 		throw new Error('p2p: nodeHash must be 64 hex characters')
-	return Buffer.from(`${LINK_HANDSHAKE_DOMAIN}\0${nonce}\0${binding}\0${nodeHash}`, 'utf8')
+	return Buffer.from(`${LINK_HANDSHAKE_DOMAIN}\0${peerNonce}\0${binding}\0${localNodeHash}`, 'utf8')
 }
 
 /**
@@ -56,10 +55,10 @@ export function buildHello(options = {}) {
 		const derived = keyPairFromSeed(Buffer.from(ensureNodeSeed(), 'hex'))
 		publicKey = derived.publicKey
 	}
-	const nodeHash = normalizeHex64(options.nodeHash || getNodeHash())
-	const nodePubKey = normalizeHex64(options.nodePubKey || Buffer.from(publicKey).toString('hex'))
-	const nonce = normalizeHex64(options.nonce || randomBytes(32).toString('hex'))
-	if (!isHex64(nodeHash) || !isHex64(nodePubKey) || !isHex64(nonce))
+	const nodeHash = isHex64(options.nodeHash || getNodeHash())
+	const nodePubKey = isHex64(options.nodePubKey || Buffer.from(publicKey).toString('hex'))
+	const nonce = isHex64(options.nonce || randomBytes(32).toString('hex'))
+	if (!nodeHash || !nodePubKey || !nonce)
 		throw new Error('p2p: invalid hello fields')
 	if (pubKeyHash(Buffer.from(nodePubKey, 'hex')) !== nodeHash)
 		throw new Error('p2p: hello nodePubKey does not match nodeHash')
@@ -78,7 +77,7 @@ export async function buildAuth(peerNonce, localBinding, options = {}) {
 		? Buffer.from(options.secretKey)
 		: Buffer.from(ensureNodeSeed(), 'hex')
 	const { publicKey, secretKey } = keyPairFromSeed(seed)
-	const nodeHash = normalizeHex64(options.nodeHash || pubKeyHash(publicKey))
+	const nodeHash = options.nodeHash || pubKeyHash(publicKey)
 	if (nodeHash !== pubKeyHash(publicKey))
 		throw new Error('p2p: auth nodeHash does not match secretKey')
 	const message = buildAuthMessage(peerNonce, localBinding, nodeHash)
@@ -92,10 +91,10 @@ export async function buildAuth(peerNonce, localBinding, options = {}) {
  * @returns {{ nodeHash: string, nodePubKey: string, nonce: string } | null} 规范化 hello 或 null
  */
 export function parseHello(hello) {
-	const nodeHash = normalizeHex64(hello?.nodeHash)
-	const nodePubKey = normalizeHex64(hello?.nodePubKey)
-	const nonce = normalizeHex64(hello?.nonce)
-	if (!isHex64(nodeHash) || !isHex64(nodePubKey) || !isHex64(nonce)) return null
+	const nodeHash = isHex64(hello?.nodeHash)
+	const nodePubKey = isHex64(hello?.nodePubKey)
+	const nonce = isHex64(hello?.nonce)
+	if (!nodeHash || !nodePubKey || !nonce) return null
 	try {
 		if (pubKeyHash(Buffer.from(nodePubKey, 'hex')) !== nodeHash) return null
 	}
@@ -116,11 +115,11 @@ export function parseHello(hello) {
 export async function verifyAuth(hello, auth, expectedNonce, remoteBinding) {
 	const parsedHello = parseHello(hello)
 	if (!parsedHello) return null
-	const signatureHex = String(auth?.sig ?? '')
+	const signatureHex = isSignatureHex128(auth?.sig)
 	const binding = normalizeLinkBinding(remoteBinding)
-	if (!isSignatureHex128(signatureHex) || !binding) return null
-	const normalizedNonce = normalizeHex64(expectedNonce)
-	if (!isHex64(normalizedNonce)) return null
+	if (!signatureHex || !binding) return null
+	const normalizedNonce = isHex64(expectedNonce)
+	if (!normalizedNonce) return null
 	const message = buildAuthMessage(normalizedNonce, binding, parsedHello.nodeHash)
 	const ok = await verify(
 		Buffer.from(signatureHex, 'hex'),
@@ -137,38 +136,148 @@ export async function verifyAuth(hello, auth, expectedNonce, remoteBinding) {
  * @param {string} nodeHash 节点 nodeHash
  * @param {number | null} [tcpPort=null] 可选 LAN TCP 监听端口（签入消息）
  * @param {unknown} [lanHosts=null] 可选 LAN IPv4 列表（签入消息）
+ * @param {string | null} [relayBlobHex=null] 可选规范化 relay 字段 hex 段（签入消息）
  * @returns {Uint8Array} 待签名消息字节
  */
-export function buildAdvertMessage(rendezvousKey, ts, nodeHash, tcpPort = null, lanHosts = null) {
-	const base = `fount-advert\0${rendezvousKey}\0${ts}\0${normalizeHex64(nodeHash)}`
+export function buildAdvertMessage(rendezvousKey, ts, nodeHash, tcpPort = null, lanHosts = null, relayBlobHex = null) {
+	let message = `fount-advert\0${rendezvousKey}\0${ts}\0${nodeHash}`
 	const port = normalizeTcpPort(tcpPort)
-	let message = port ? `${base}\0${port}` : base
+	if (port) message += `\0${port}`
 	const hosts = normalizeLanHosts(lanHosts)
 	if (hosts.length) message += `\0${hosts.join(',')}`
+	if (relayBlobHex) message += `\0relays:${relayBlobHex}`
 	return Buffer.from(message, 'utf8')
 }
 
 /**
- * 构造带签名的 discovery advert（tcpPort / lanHosts 一并签入消息）。
+ * 规范化并裁剪入站（不可信）advert 携带的 relay 字段：无效项丢弃并记审计日志，不抛错。
+ * - pool：url 经 normalize 有效且 rttMs∈[0,MAX_RTT_MS]，取整、去重、裁剪前 MAX_ADVERT_RELAY_POOL。
+ * - listen：url normalize 有效、去重、裁剪前 MAX_ADVERT_LISTEN_RELAYS。
+ * - 每个丢弃项记审计日志（含原始值），不静默。
+ * @param {unknown} rawPool 原始 pool（[{url, rttMs}]）
+ * @param {unknown} rawListen 原始 listen（[url]）
+ * @returns {{ pool: Array<{ url: string, rtt: number }>, listen: string[] }} 规范化结果
+ */
+export function sanitizeAdvertRelayFields(rawPool, rawListen) {
+	/** @type {Array<{ url: string, rtt: number }>} */
+	const pool = []
+	/** @type {Set<string>} */
+	const seenPool = new Set()
+	if (Array.isArray(rawPool)) for (const item of rawPool) {
+		const url = normalizeNostrRelayUrl(item?.url)
+		if (!url) {
+			nodeDebug('invalidRelayUrl', { url: String(item?.url), reason: 'advert-pool-invalid-url' })
+			continue
+		}
+		const rtt = Number(item?.rttMs ?? item?.rtt)
+		if (!Number.isFinite(rtt) || rtt < 0 || rtt > MAX_RTT_MS) {
+			nodeDebug('invalidRelayUrl', { url, reason: 'advert-pool-invalid-rtt', rttMs: item?.rttMs ?? item?.rtt })
+			continue
+		}
+		if (seenPool.has(url)) continue
+		seenPool.add(url)
+		pool.push({ url, rtt: Math.round(rtt) })
+		if (pool.length >= MAX_ADVERT_RELAY_POOL) break
+	}
+
+	/** @type {string[]} */
+	const listen = []
+	/** @type {Set<string>} */
+	const seenListen = new Set()
+	if (Array.isArray(rawListen)) for (const raw of rawListen) {
+		const url = normalizeNostrRelayUrl(raw)
+		if (!url) {
+			nodeDebug('invalidRelayUrl', { url: String(raw), reason: 'advert-listen-invalid-url' })
+			continue
+		}
+		if (seenListen.has(url)) continue
+		seenListen.add(url)
+		listen.push(url)
+		if (listen.length >= MAX_ADVERT_LISTEN_RELAYS) break
+	}
+
+	return { pool, listen }
+}
+
+/**
+ * 构建规范化 relay 字段的 canonical blob（pool/listen 各按 url 排序 → `{p,l}` JSON → UTF-8 → hex）。
+ * @param {Array<{ url: string, rtt: number }>} pool 规范化 pool
+ * @param {string[]} listen 规范化 listen
+ * @returns {string} hex 编码 blob
+ */
+export function canonicalAdvertRelayBlob(pool, listen) {
+	return Buffer.from(JSON.stringify({
+		p: [...pool].sort((a, b) => a.url < b.url ? -1 : a.url > b.url ? 1 : 0),
+		l: [...listen].sort(),
+	}), 'utf8').toString('hex')
+}
+
+/**
+ * 严格规范化本机（出站）提供的 relay 字段：无效数据立即抛错，不静默丢弃。
+ * 本地调用方应提供已规范化字段；入站校验仍走 lenient 的 sanitizeAdvertRelayFields。
+ * @param {unknown} rawPool 原始 pool（[{url, rttMs}]）
+ * @param {unknown} rawListen 原始 listen（[url]）
+ * @returns {{ pool: Array<{ url: string, rtt: number }>, listen: string[] }} 规范化结果
+ */
+function normalizeLocalRelayFields(rawPool, rawListen) {
+	/** @type {Array<{ url: string, rtt: number }>} */
+	const pool = []
+	/** @type {Set<string>} */
+	const seenPool = new Set()
+	if (rawPool != null && !Array.isArray(rawPool)) throw new Error('p2p: advert pool invalid type')
+	if (Array.isArray(rawPool)) for (const item of rawPool) {
+		const url = normalizeNostrRelayUrl(item?.url)
+		if (!url) throw new Error('p2p: advert pool invalid url')
+		const rtt = Number(item?.rttMs ?? item?.rtt)
+		if (!Number.isFinite(rtt) || rtt < 0 || rtt > MAX_RTT_MS)
+			throw new Error('p2p: advert pool invalid rtt')
+		if (seenPool.has(url)) continue
+		seenPool.add(url)
+		pool.push({ url, rtt: Math.round(rtt) })
+		if (pool.length >= MAX_ADVERT_RELAY_POOL) break
+	}
+
+	/** @type {string[]} */
+	const listen = []
+	/** @type {Set<string>} */
+	const seenListen = new Set()
+	if (rawListen != null && !Array.isArray(rawListen)) throw new Error('p2p: advert listen invalid type')
+	if (Array.isArray(rawListen)) for (const raw of rawListen) {
+		const url = normalizeNostrRelayUrl(raw)
+		if (!url) throw new Error('p2p: advert listen invalid url')
+		if (seenListen.has(url)) continue
+		seenListen.add(url)
+		listen.push(url)
+		if (listen.length >= MAX_ADVERT_LISTEN_RELAYS) break
+	}
+
+	return { pool, listen }
+}
+
+/**
+ * 构造带签名的 discovery advert（tcpPort / lanHosts / relay 字段一并签入消息）。
  * @param {string} rendezvousKey discovery 内部汇合键
  * @param {number} [ts=Date.now()] 时间戳（毫秒）
- * @param {{ secretKey?: Uint8Array, nodeHash?: string, nodePubKey?: string, tcpPort?: number, lanHosts?: unknown } | null} [options] 签名身份；可选 LAN 监听端口与本机 IPv4 列表
- * @returns {Promise<{ nodeHash: string, nodePubKey: string, ts: number, sig: string, tcpPort?: number, lanHosts?: string[] }>} 签名 advert
+ * @param {{ secretKey?: Uint8Array, nodeHash?: string, nodePubKey?: string, tcpPort?: number, lanHosts?: unknown, nostrRelayPool?: unknown, listenNostrRelays?: unknown } | null} [options] 签名身份；可选 LAN 监听端口、本机 IPv4 列表与 relay 字段
+ * @returns {Promise<{ nodeHash: string, nodePubKey: string, ts: number, sig: string, tcpPort?: number, lanHosts?: string[], nostrRelayPool?: Array<{ url: string, rtt: number }>, listenNostrRelays?: string[] }>} 签名 advert
  */
 export async function buildSignedAdvert(rendezvousKey, ts = Date.now(), options = null) {
 	const seed = options?.secretKey
 		? Buffer.from(options.secretKey)
 		: Buffer.from(ensureNodeSeed(), 'hex')
 	const { publicKey, secretKey } = keyPairFromSeed(seed)
-	const nodeHash = normalizeHex64(options?.nodeHash || pubKeyHash(publicKey))
-	const nodePubKey = normalizeHex64(options?.nodePubKey || Buffer.from(publicKey).toString('hex'))
+	const nodeHash = options?.nodeHash || pubKeyHash(publicKey)
+	const nodePubKey = options?.nodePubKey || Buffer.from(publicKey).toString('hex')
 	if (pubKeyHash(Buffer.from(nodePubKey, 'hex')) !== nodeHash)
 		throw new Error('p2p: advert nodePubKey does not match nodeHash')
 	const tcpPort = normalizeTcpPort(options?.tcpPort)
 	if (options?.tcpPort && !tcpPort)
 		throw new Error('p2p: advert tcpPort invalid')
 	const lanHosts = normalizeLanHosts(options?.lanHosts)
-	const message = buildAdvertMessage(rendezvousKey, ts, nodeHash, tcpPort, lanHosts)
+	// 出站字段要求已规范化，无效数据直接抛错（入站路径才用 lenient sanitize）。
+	const normalized = normalizeLocalRelayFields(options?.nostrRelayPool, options?.listenNostrRelays)
+	const message = buildAdvertMessage(rendezvousKey, ts, nodeHash, tcpPort, lanHosts,
+		canonicalAdvertRelayBlob(normalized.pool, normalized.listen))
 	const sig = await sign(message, secretKey)
 	const advert = {
 		nodeHash,
@@ -178,28 +287,31 @@ export async function buildSignedAdvert(rendezvousKey, ts = Date.now(), options
 	}
 	if (tcpPort) advert.tcpPort = tcpPort
 	if (lanHosts.length) advert.lanHosts = lanHosts
+	if (normalized.pool.length) advert.nostrRelayPool = normalized.pool
+	if (normalized.listen.length) advert.listenNostrRelays = normalized.listen
 	return advert
 }
 
 /**
- * 验证 discovery advert 签名与时间戳，成功返回发布者 nodeHash。
+ * 验证 discovery advert 签名与时间戳，成功返回发布者 nodeHash 与规范化后的 relay 字段。
  * @param {string} rendezvousKey 期望的汇合键
  * @param {unknown} advert 原始 advert 载荷
  * @param {number} [now=Date.now()] 当前时间（毫秒）
  * @param {number} [maxSkewMs=10 * 60_000] 允许的最大时钟偏差（毫秒）
- * @returns {Promise<string | null>} 验证通过的 nodeHash，失败返回 null
+ * @returns {Promise<{ nodeHash: string, relayPool: Array<{ url: string, rtt: number }>, listenRelays: string[] } | null>} 验证通过返回 nodeHash 与规范化 relay 字段，失败返回 null
  */
 export async function verifySignedAdvert(rendezvousKey, advert, now = Date.now(), maxSkewMs = 10 * 60_000) {
 	const parsedHello = parseHello({ nodeHash: advert?.nodeHash, nodePubKey: advert?.nodePubKey, nonce: '0'.repeat(64) })
 	if (!parsedHello) return null
 	const ts = Number(advert?.ts)
-	const sig = String(advert?.sig ?? '')
-	if (!Number.isFinite(ts) || Math.abs(now - ts) > maxSkewMs || !isSignatureHex128(sig)) return null
-	const hasTcpPortField = !!advert?.tcpPort
+	const sig = isSignatureHex128(advert?.sig)
+	if (!Number.isFinite(ts) || Math.abs(now - ts) > maxSkewMs || !sig) return null
 	const tcpPort = normalizeTcpPort(advert?.tcpPort)
-	if (hasTcpPortField && !tcpPort) return null
-	const lanHosts = normalizeLanHosts(advert?.lanHosts)
-	const message = buildAdvertMessage(rendezvousKey, ts, parsedHello.nodeHash, tcpPort, lanHosts)
-	const ok = await verify(Buffer.from(sig, 'hex'), message, Buffer.from(parsedHello.nodePubKey, 'hex'))
-	return ok ? parsedHello.nodeHash : null
+	if (advert?.tcpPort != null && !tcpPort) return null
+	const sanitized = sanitizeAdvertRelayFields(advert?.nostrRelayPool, advert?.listenNostrRelays)
+	if (!await verify(Buffer.from(sig, 'hex'),
+		buildAdvertMessage(rendezvousKey, ts, parsedHello.nodeHash, tcpPort, normalizeLanHosts(advert?.lanHosts),
+			canonicalAdvertRelayBlob(sanitized.pool, sanitized.listen)),
+		Buffer.from(parsedHello.nodePubKey, 'hex'))) return null
+	return { nodeHash: parsedHello.nodeHash, relayPool: sanitized.pool, listenRelays: sanitized.listen }
 }

package/link/pipe.mjs

@@ -1,5 +1,4 @@
 import { toBytes } from '../core/bytes_codec.mjs'
-import { normalizeHex64 } from '../core/hexIds.mjs'
 import { ms } from '../utils/duration.mjs'
 import { emitSafe } from '../utils/emit_safe.mjs'
 import { createLruMap } from '../utils/lru.mjs'
@@ -92,7 +91,7 @@ export function createLinkPipe(options) {
 	const heartbeatMs = Number(options.heartbeatMs) || ms('15s')
 	const idleTimeoutMs = Number(options.idleTimeoutMs) || ms('45s')
 	const handshakeTimeoutMs = Number(options.handshakeTimeoutMs) || ms('10s')
-	const targetNodeHash = normalizeHex64(options.nodeHash || '')
+	const targetNodeHash = options.nodeHash || ''
 	let closed = false
 	let ready = false
 	let closeReason = 'closed'

package/link/providers/ble_gatt.mjs

@@ -1,7 +1,6 @@
 import { Buffer } from 'node:buffer'
 import { randomBytes } from 'node:crypto'
 
-import { normalizeHex64 } from '../../core/hexIds.mjs'
 import { getBtPeerHint } from '../../discovery/bt/peer_hints.mjs'
 import { canUseBluetoothRuntime, loadBleno, loadNoble, resolveBtRole, waitPoweredOn } from '../../discovery/bt/runtime.mjs'
 import { asLinkHandle } from '../pipe.mjs'
@@ -55,7 +54,7 @@ async function openGattPipe(options) {
 
 	if (options.initiator)
 		await Promise.resolve(options.write(Buffer.from(
-			buildLinkOpen(normalizeHex64(options.linkId), options.localIdentity?.nodeHash),
+			buildLinkOpen(options.linkId, options.localIdentity?.nodeHash),
 			'utf8',
 		)))
 
@@ -69,7 +68,7 @@ async function openGattPipe(options) {
  * @returns {Promise<import('./index.mjs').LinkHandle>} 已就绪的 link
  */
 async function dialBleGatt(options) {
-	const remoteNodeHash = normalizeHex64(options.nodeHash)
+	const remoteNodeHash = options.nodeHash
 	const hint = getBtPeerHint(remoteNodeHash)
 	if (!hint) throw new Error('p2p: ble_gatt no peer hint')
 	const noble = await loadNoble()