@steve02081504/fount-p2p 0.0.33 → 0.0.34

package/discovery/nostr.mjs

@@ -25,6 +25,10 @@ export const DEFAULT_RELAY_URLS = [
 	'wss://relay.damus.io',
 	'wss://nos.lol',
 	'wss://relay.nostr.band',
+	'wss://relay.nostr.com',
+	'wss://nostr.bitcoiner.social',
+	'wss://nostr.mom',
+	'wss://relay.snort.social',
 ]
 
 /** 单中继 WebSocket 首连超时（短超时 + 并行，避免串行 10s×N）。 */
@@ -44,6 +48,9 @@ export const NOSTR_ADVERT_KIND = 30787
 /** Nostr signal 事件 kind（ephemeral，实时转发）。 */
 export const NOSTR_SIGNAL_KIND = 20787
 
+/** 打广告用的话题 tag（hashtag，NIP-01），公开可被搜索聚合。 */
+const NOSTR_TOPIC_TAG = ['t', 'fount']
+
 const ADVERT_TTL_MS = 10 * 60_000
 
 /** @type {Map<string, number>} 网络域 nodeHash → lastSeenAt */
@@ -925,7 +932,7 @@ export function createNostrDiscoveryProvider(options = {}) {
 				const bytes = encryptSignalPacket(rendezvousKey, { type: 'advert', body: advertBody })
 				const event = await signNostrEvent(
 					NOSTR_ADVERT_KIND,
-					[['t', rendezvousKey], ['x', 'advert'], ['d', rendezvousKey]],
+					[NOSTR_TOPIC_TAG, ['t', rendezvousKey], ['x', 'advert'], ['d', rendezvousKey]],
 					bytesToBase64(bytes),
 					secretKey,
 				)
@@ -957,7 +964,7 @@ export function createNostrDiscoveryProvider(options = {}) {
 			const rendezvousKey = nodeRendezvousKey(hash)
 			const event = await signNostrEvent(
 				NOSTR_SIGNAL_KIND,
-				[['t', rendezvousKey], ['x', 'signal'], ['p', hash]],
+				[NOSTR_TOPIC_TAG, ['t', rendezvousKey], ['x', 'signal'], ['p', hash]],
 				bytesToBase64(bytes),
 				secretKey,
 			)
@@ -1019,7 +1026,7 @@ export function createNostrDiscoveryProvider(options = {}) {
 				const bytes = encryptSignalPacket(rendezvousKey, { type: 'advert', body: advertBody })
 				const event = await signNostrEvent(
 					NOSTR_ADVERT_KIND,
-					[['t', rendezvousKey], ['x', 'advert'], ['d', rendezvousKey]],
+					[NOSTR_TOPIC_TAG, ['t', rendezvousKey], ['x', 'advert'], ['d', rendezvousKey]],
 					bytesToBase64(bytes),
 					secretKey,
 				)

package/link/frame.mjs

@@ -1,6 +1,6 @@
 import { randomBytes } from 'node:crypto'
 
-import { bytesToHex, hexToBytes, toBytes } from '../core/bytes_codec.mjs'
+import { bytesToBase64, bytesToHex, hexToBytes, toBytes } from '../core/bytes_codec.mjs'
 
 /** frameId 字段字节长度（128 位）。 */
 export const FRAME_ID_BYTES = 16
@@ -40,6 +40,28 @@ export function randomFrameIdHex() {
 	return bytesToHex(randomBytes(FRAME_ID_BYTES))
 }
 
+/**
+ * 在单包字符上限下，求单片最大可承载 chunk 字节数。
+ * 以 base64 逐片精确贴合上限为目标，用二分在 [0, limit] 内找最大 chunkBytes，
+ * 使 base64Len(headerBytes + chunkBytes) <= limit —— 最大化单帧载荷利用率，
+ * 而不是按 base64 膨胀预留固定比例（预留比例会浪费余量且对帧头/填充不精确）。
+ * @param {number} maxPayloadChars 单包载荷字符上限（编码后）
+ * @param {(bytes: Uint8Array) => string} [encode] 载荷编码函数（默认 base64）
+ * @param {number} [headerBytes=FRAME_HEADER_BYTES] 帧头字节数
+ * @returns {number} 最大 chunk 字节数（>=0）
+ */
+export function maxFrameChunkBytesForPayload(maxPayloadChars, encode = bytesToBase64, headerBytes = FRAME_HEADER_BYTES) {
+	const limit = Math.max(1, Math.floor(Number(maxPayloadChars) || 0))
+	let lowerBound = 0
+	let upperBound = limit
+	while (lowerBound < upperBound) {
+		const candidateChunkBytes = Math.ceil((lowerBound + upperBound + 1) / 2)
+		if (encode(new Uint8Array(headerBytes + candidateChunkBytes)).length <= limit) lowerBound = candidateChunkBytes
+		else upperBound = candidateChunkBytes - 1
+	}
+	return lowerBound
+}
+
 /**
  * 将消息切成带帧头的分片。
  * @param {string | Uint8Array} frameId 消息 id（hex 或 16 字节）
@@ -50,7 +72,7 @@ export function randomFrameIdHex() {
 export function encodeFrames(frameId, bytes, maxChunkBytes = DEFAULT_MAX_FRAME_CHUNK_BYTES) {
 	const body = toBytes(bytes)
 	const idBytes = normalizeFrameIdBytes(frameId)
-	const chunkBytes = Math.max(256, Math.min(DEFAULT_MAX_MESSAGE_BYTES, Number(maxChunkBytes) || DEFAULT_MAX_FRAME_CHUNK_BYTES))
+	const chunkBytes = Math.min(DEFAULT_MAX_MESSAGE_BYTES, Number(maxChunkBytes) || DEFAULT_MAX_FRAME_CHUNK_BYTES)
 	const total = Math.max(1, Math.ceil(body.byteLength / chunkBytes))
 	/** @type {Uint8Array[]} */
 	const frames = []

package/link/pipe.mjs

@@ -4,7 +4,7 @@ import { ms } from '../utils/duration.mjs'
 import { emitSafe } from '../utils/emit_safe.mjs'
 import { createLruMap } from '../utils/lru.mjs'
 
-import { createReassembler, encodeFrames, randomFrameIdHex } from './frame.mjs'
+import { createReassembler, DEFAULT_MAX_FRAME_CHUNK_BYTES, encodeFrames, FRAME_HEADER_BYTES, randomFrameIdHex } from './frame.mjs'
 import { buildAuth, buildHello, parseHello, verifyAuth } from './handshake.mjs'
 
 const encoder = new TextEncoder()
@@ -81,10 +81,14 @@ export function asLinkHandle(pipe, extras = {}) {
  * @param {number} [options.idleTimeoutMs] 空闲超时
  * @param {number} [options.handshakeTimeoutMs] 握手超时
  * @param {number} [options.rttWindowSize] RTT 样本滑动窗口大小
+ * @param {number} [options.maxFrameBytes] 单帧最大字节数（provider 按其传输载荷上限折算；默认 15 KiB）
  * @returns {object} link 句柄 + 入站 API
  */
 export function createLinkPipe(options) {
 	const { providerId, level } = options
+	const maxFrameBytes = options.maxFrameBytes == null ? DEFAULT_MAX_FRAME_CHUNK_BYTES : Number(options.maxFrameBytes)
+	if (maxFrameBytes < FRAME_HEADER_BYTES)
+		throw new Error(`p2p: ${providerId} maxFrameBytes too small to carry a frame header`)
 	const heartbeatMs = Number(options.heartbeatMs) || ms('15s')
 	const idleTimeoutMs = Number(options.idleTimeoutMs) || ms('45s')
 	const handshakeTimeoutMs = Number(options.handshakeTimeoutMs) || ms('10s')
@@ -348,7 +352,7 @@ export function createLinkPipe(options) {
 			payload: envelope.payload ?? null,
 			frameId,
 		}))
-		for (const frame of encodeFrames(frameId, bytes)) {
+		for (const frame of encodeFrames(frameId, bytes, maxFrameBytes)) {
 			const sent = options.sendFrame(envelope.action, frame)
 			if (sent?.then) await sent
 			sentFrames++

package/link/providers/nostr.mjs

@@ -4,16 +4,102 @@ import { randomBytes } from 'node:crypto'
 import { base64ToBytes, bytesToBase64 } from '../../core/bytes_codec.mjs'
 import { normalizeHex64 } from '../../core/hexIds.mjs'
 import { getDiscoveryProvider, sendNodeSignalPacket } from '../../discovery/index.mjs'
-import { resolveNostrRelayUrls } from '../../discovery/nostr.mjs'
+import { NOSTR_SIGNAL_KIND, resolveNostrRelayUrls } from '../../discovery/nostr.mjs'
 import { ms } from '../../utils/duration.mjs'
 import { createLruMap } from '../../utils/lru.mjs'
+import { FRAME_HEADER_BYTES, maxFrameChunkBytesForPayload } from '../frame.mjs'
 import { asLinkHandle } from '../pipe.mjs'
 
 import { LINK_LEVEL_NOSTR } from './levels.mjs'
 import { createLinkIdBoundPipe } from './link_id_pipe.mjs'
 
-/** 单包 payload（UTF-8 / base64）上限，避免撞 relay content 限制。 */
-const MAX_LINK_PAYLOAD_CHARS = 12 * 1024
+/** 单包 payload（UTF-8 / base64）上限，避免撞 relay content 限制。
+ *  默认兜底取 2026-08 本机对默认公共 relay 的 NIP-11 `max_message_length` 非零最小值（131072 = nostr.mom）。
+ *  有 relay 信息时用实测非零最小值覆盖（见 refreshPayloadCap），无 relay / 未探测到时用此默认。 */
+export const MAX_LINK_PAYLOAD_CHARS = 131072
+
+/** relay info（NIP-11）单次探测超时。 */
+const RELAY_INFO_TIMEOUT_MS = ms('4s')
+/** 实测 payload 上限缓存有效期。 */
+const PAYLOAD_CAP_CACHE_TTL_MS = ms('10m')
+const textEncoder = new TextEncoder()
+/** 固定 64 位 hex 占位（id/pubkey/sig/rendezvousKey/nodeHash 均固定宽度）。 */
+const HEX64 = 'a'.repeat(64)
+/** AES-GCM 封装输出中的固定长度字段占位：iv = base64(12B) = 16，authTag = base64(16B) = 24。 */
+const GCM_IV_BASE64 = 'a'.repeat(16)
+const GCM_AUTH_TAG_BASE64 = 'a'.repeat(24)
+
+/**
+ * 估算把给定 link 包发布为 Nostr EVENT 后，完整 WebSocket 消息（["EVENT", event]）的 UTF-8 字节长度。
+ * id/pubkey/sig/rendezvousKey/nodeHash 均为固定 64 hex，created_at/kind/tags 固定，故长度仅随 packet.payload 变化，
+ * 可同步精确构造（含加密封装壳与 event 字段），无需真正 AES-GCM 封装与 Schnorr 签名。
+ * @param {object} packet link 包
+ * @returns {number} 完整消息字节长度
+ */
+export function estimateEventMessageBytes(packet) {
+	// encryptSignalPacket 输出全 ASCII：{"iv":<16>,"authTag":<24>,"ciphertext":base64(packetJson bytes)}。
+	return textEncoder.encode(JSON.stringify(['EVENT', {
+		id: HEX64,
+		pubkey: HEX64,
+		created_at: Math.floor(Date.now() / 1000),
+		kind: NOSTR_SIGNAL_KIND,
+		tags: [['t', HEX64], ['x', 'signal'], ['p', HEX64]],
+		content: bytesToBase64(textEncoder.encode(JSON.stringify({
+			iv: GCM_IV_BASE64,
+			authTag: GCM_AUTH_TAG_BASE64,
+			ciphertext: bytesToBase64(textEncoder.encode(JSON.stringify(packet))),
+		}))),
+		sig: HEX64,
+	}])).length
+}
+
+/** relay cap 低于此字符数视为无法承载最小正 chunk（帧头 + 1 字节 chunk 的完整 EVENT 封装），从统一上限中剔除。
+ *  这类 relay 即便能传也无法携带有效载荷（maxFrameChunkBytesForPayload 得 0），参与取最小值只会无谓拖低/毒化整条链路。 */
+export const MIN_USABLE_RELAY_CAP_CHARS = estimateEventMessageBytes({
+	type: 'link',
+	op: 'b',
+	from: HEX64,
+	linkId: HEX64,
+	payload: bytesToBase64(new Uint8Array(FRAME_HEADER_BYTES + 1)),
+})
+
+/**
+ * 拉取单个 relay 的 NIP-11 relay info 并读取 max_message_length。
+ * @param {string} relayUrl relay URL
+ * @returns {Promise<number | null>} 非零上限；失败/未声明返回 null
+ */
+async function queryRelayMaxMessageLength(relayUrl) {
+	const httpUrl = relayUrl.replace(/^wss:/, 'https:').replace(/^ws:/, 'http:')
+	const controller = new AbortController()
+	const timer = setTimeout(() => controller.abort(), RELAY_INFO_TIMEOUT_MS)
+	timer.unref?.()
+	try {
+		const response = await fetch(httpUrl, { headers: { Accept: 'application/nostr+json' }, signal: controller.signal })
+		const info = await response.json()
+		const limit = { ...info?.limit || {}, ...info?.limitation || {} }
+		const value = Number(limit.max_message_length)
+		return Number.isFinite(value) && value > 0 ? value : null
+	}
+	catch {
+		return null
+	}
+	finally {
+		clearTimeout(timer)
+	}
+}
+
+/**
+ * 从各 relay 上报的 cap 中取「可用」（>= 最小可用帧，能产生正数 chunk budget）的非零最小值。
+ * cap 过低的 relay 无法承载最小正 chunk（完整 EVENT 封装装不下），取最小值只会拖低/毒化整条链路，故剔除；
+ * 剩余 relay 的最小值保证任意一个可用 relay 都能传该帧（publishEvent 只要求任一 relay 接受）。
+ * @param {Array<number | null | undefined>} caps 各 relay 上报的 cap
+ * @returns {number | null} 可用最小值；无可用 relay 返回 null
+ */
+export function minUsablePayloadCap(caps) {
+	const usable = caps.filter(value => Number.isFinite(value) && value >= MIN_USABLE_RELAY_CAP_CHARS)
+	return usable.length ? Math.min(...usable) : null
+}
+
 /** open 到达前为同一 linkId 暂存的 c/b 包上限。 */
 const PENDING_PACKETS_MAX = 32
 /** Nostr 链握手超时（relay RTT 更慢）。 */
@@ -35,11 +121,49 @@ async function publishLinkPacket(remoteNodeHash, packet) {
 /**
  * 创建 Nostr 末位数据链路 provider（level = -∞）。
  * @param {{ getRelayUrls?: () => string[] }} [options] 中继解析（测试可注入）
- * @returns {import('./index.mjs').LinkProvider & { deliverPacket: (packet: object) => void }} provider
+	 * @returns {import('./index.mjs').LinkProvider & { deliverPacket: (packet: object) => void | Promise<void> }} provider
  */
 export function createNostrLinkProvider(options = {}) {
 	const resolveRelayUrls = options.getRelayUrls || resolveNostrRelayUrls
 
+	/** @type {number | null} 本实例实测非零最小 payload 上限（NIP-11 max_message_length） */
+	let queriedPayloadCap = null
+	/** @type {number} 本实例最近一次实测时间戳 */
+	let payloadCapQueriedAt = 0
+	/** @type {Promise<void> | null} 本实例进行中的探测（去重并发） */
+	let payloadCapRefreshPromise = null
+
+	/**
+	 * 探测各 relay 的 payload 上限，缓存「可用 relay」的最小值（TTL 内不重复探测）。
+	 * 仅在实际 wss/ws/https/http 中继上探测；失败或未声明的 relay 忽略。
+	 * @param {string[]} relayUrls 中继 URL 列表
+	 * @returns {Promise<void>}
+	 */
+	async function refreshPayloadCap(relayUrls) {
+		if (payloadCapRefreshPromise) return payloadCapRefreshPromise
+		if (queriedPayloadCap != null && Date.now() - payloadCapQueriedAt < PAYLOAD_CAP_CACHE_TTL_MS) return
+		const urls = [...new Set(relayUrls.filter(url => /^(wss?|https?):\/\//i.test(url)))]
+		if (!urls.length) return
+		payloadCapRefreshPromise = Promise.allSettled(urls.map(queryRelayMaxMessageLength))
+			.then(results => {
+				const value = minUsablePayloadCap(results.map(result => result.status === 'fulfilled' ? result.value : null))
+				if (value != null) {
+					queriedPayloadCap = value
+					payloadCapQueriedAt = Date.now()
+				}
+			})
+			.finally(() => { payloadCapRefreshPromise = null })
+		return payloadCapRefreshPromise
+	}
+
+	/**
+	 * 当前生效的单包上限：有 relay 实测非零最小值则用它（最大化载荷利用率），否则用默认兜底。
+	 * @returns {number} 上限（针对完整 Nostr EVENT 消息的字节数）
+	 */
+	function currentMaxPayloadChars() {
+		return queriedPayloadCap ?? MAX_LINK_PAYLOAD_CHARS
+	}
+
 	/** @type {((link: import('./index.mjs').LinkHandle) => void) | null} */
 	let onInbound = null
 	/** @type {object | null} */
@@ -109,11 +233,10 @@ export function createNostrLinkProvider(options = {}) {
 	 * @param {string} linkId 链路 id
 	 * @param {string} op open|c|b|close
 	 * @param {string} [payload] 可选载荷
+	 * @param {number} [maxChars=MAX_LINK_PAYLOAD_CHARS] 该 pipe 冻结的字符上限
 	 * @returns {Promise<void>}
 	 */
-	async function sendOp(remoteNodeHash, linkId, op, payload) {
-		if (payload != null && payload.length > MAX_LINK_PAYLOAD_CHARS)
-			throw new Error('p2p: nostr link payload too large')
+	async function sendOp(remoteNodeHash, linkId, op, payload, maxChars = MAX_LINK_PAYLOAD_CHARS) {
 		const packet = {
 			type: 'link',
 			op,
@@ -121,6 +244,8 @@ export function createNostrLinkProvider(options = {}) {
 			linkId,
 		}
 		if (payload != null) packet.payload = payload
+		if (estimateEventMessageBytes(packet) > maxChars)
+			throw new Error('p2p: nostr link payload too large')
 		await publishLinkPacket(remoteNodeHash, packet)
 	}
 
@@ -130,6 +255,19 @@ export function createNostrLinkProvider(options = {}) {
 	 */
 	function openPipe(opts) {
 		const { linkId, remoteNodeHash, initiator } = opts
+		// 冻结该 pipe 的字符上限：按完整 Nostr EVENT 消息字节数切帧，与发送校验共用同一上限，保持自洽。
+		const payloadChars = currentMaxPayloadChars()
+		const maxFrameBytes = maxFrameChunkBytesForPayload(
+			payloadChars,
+			// maxFrameChunkBytesForPayload 用 encode(...).length 度量载荷，故返回等长字符串。
+			frameBytes => 'x'.repeat(estimateEventMessageBytes({
+				type: 'link',
+				op: 'b',
+				from: (opts.localIdentity || localIdentity)?.nodeHash || '',
+				linkId,
+				payload: bytesToBase64(frameBytes),
+			})),
+		)
 		const pipe = createLinkIdBoundPipe({
 			providerId: 'nostr',
 			level: LINK_LEVEL_NOSTR,
@@ -137,6 +275,7 @@ export function createNostrLinkProvider(options = {}) {
 			linkId,
 			nodeHash: remoteNodeHash,
 			localIdentity: opts.localIdentity || localIdentity,
+			maxFrameBytes,
 			handshakeTimeoutMs: NOSTR_HANDSHAKE_TIMEOUT_MS,
 			heartbeatMs: NOSTR_HEARTBEAT_MS,
 			idleTimeoutMs: NOSTR_IDLE_TIMEOUT_MS,
@@ -145,7 +284,7 @@ export function createNostrLinkProvider(options = {}) {
 			 * @returns {Promise<void>}
 			 */
 			async sendControlText(text) {
-				await sendOp(remoteNodeHash, linkId, 'c', text)
+				await sendOp(remoteNodeHash, linkId, 'c', text, payloadChars)
 			},
 			/**
 			 * @param {string} _action action
@@ -153,7 +292,7 @@ export function createNostrLinkProvider(options = {}) {
 			 * @returns {Promise<void>}
 			 */
 			async sendFrame(_action, frame) {
-				await sendOp(remoteNodeHash, linkId, 'b', bytesToBase64(frame))
+				await sendOp(remoteNodeHash, linkId, 'b', bytesToBase64(frame), payloadChars)
 			},
 			/**
 			 * @returns {Promise<void>}
@@ -174,9 +313,9 @@ export function createNostrLinkProvider(options = {}) {
 	/**
 	 * 入站已解密的 link 包（由信令 demux 调用）。
 	 * @param {object} packet link 包
-	 * @returns {void}
+	 * @returns {Promise<void>}
 	 */
-	function deliverPacket(packet) {
+	async function deliverPacket(packet) {
 		if (packet?.type !== 'link') return
 		const linkId = normalizeHex64(packet.linkId)
 		const from = normalizeHex64(packet.from)
@@ -187,6 +326,8 @@ export function createNostrLinkProvider(options = {}) {
 		if (op === 'open') {
 			if (sessions.has(linkId)) return
 			if (!onInbound || !localIdentity) return
+			await refreshPayloadCap(resolveRelayUrls())
+			if (sessions.has(linkId)) return
 			const pipe = openPipe({
 				linkId,
 				remoteNodeHash: from,
@@ -238,6 +379,7 @@ export function createNostrLinkProvider(options = {}) {
 			if (!remoteNodeHash) return null
 			localIdentity = dialOptions.localIdentity || localIdentity
 			if (!localIdentity?.nodeHash) throw new Error('p2p: nostr dial requires localIdentity')
+			await refreshPayloadCap(resolveRelayUrls())
 			const linkId = randomBytes(32).toString('hex')
 			const pipe = openPipe({
 				linkId,
@@ -256,6 +398,7 @@ export function createNostrLinkProvider(options = {}) {
 		ensureListening(handlers) {
 			onInbound = handlers.onInbound
 			localIdentity = handlers.localIdentity
+			void refreshPayloadCap(resolveRelayUrls())
 			return () => {
 				onInbound = null
 				for (const session of sessions.values())

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.33",
+	"version": "0.0.34",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",