@steve02081504/fount-p2p 0.0.30 → 0.0.32

package/sim/discovery.mjs

@@ -0,0 +1,259 @@
+/**
+ * 发现拓扑子模型：单 relay rendezvous + RTC 连接预算 + explore 源配额 + trusted 锚点。
+ */
+import { resolveRtcBudgetLimits } from '../transport/rtc_connection_budget.mjs'
+
+import { buildRankedNeighborAdj } from './graph_adj.mjs'
+
+/**
+ * 单 explore 源最多占用的 room 槽位（对齐 peer_pool EXPLORE_MAX_PER_SOURCE）。
+ * peer_pool 会拖入 node 存储的 fs 依赖，不宜进 sim 热路径，故此处保留常量，
+ * 由 fidelity.test.mjs 断言其与真实值一致以守住漂移。
+ */
+export const EXPLORE_MAX_PER_SOURCE = 3
+
+/** 默认 RTC room 并发连接上限（派生自真实 rtc_connection_budget 默认 maxActive） */
+export const DEFAULT_RTC_MAX_ACTIVE = resolveRtcBudgetLimits().maxActive
+
+/**
+ * @typedef {{
+ *   trustedAnchorsByObserver: Map<string, Set<string>>,
+ *   exploreByObserver: Map<string, Set<string>>,
+ *   poisonedByAttacker: Map<string, Set<string>>,
+ *   roomSlotsByObserver: Map<string, { active: Set<string>, sourceByPeer: Map<string, string>, trustedReserved: Set<string> }>,
+ *   rtcMaxActive: number,
+ * }} DiscoveryState
+ */
+
+/**
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @returns {Set<string>} 该观察者的 trusted 锚点
+ */
+function observerTrustedAnchors(state, observerId) {
+	return state.trustedAnchorsByObserver.get(observerId) ?? new Set()
+}
+
+/**
+ * @returns {DiscoveryState} 空发现状态
+ */
+export function createDiscoveryState() {
+	return {
+		trustedAnchorsByObserver: new Map(),
+		exploreByObserver: new Map(),
+		poisonedByAttacker: new Map(),
+		roomSlotsByObserver: new Map(),
+		rtcMaxActive: DEFAULT_RTC_MAX_ACTIVE,
+	}
+}
+
+/**
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @returns {{ active: Set<string>, sourceByPeer: Map<string, string>, trustedReserved: Set<string> }} room 槽位桶
+ */
+function roomBucket(state, observerId) {
+	let bucket = state.roomSlotsByObserver.get(observerId)
+	if (!bucket) {
+		bucket = { active: new Set(), sourceByPeer: new Map(), trustedReserved: new Set() }
+		state.roomSlotsByObserver.set(observerId, bucket)
+	}
+	return bucket
+}
+
+/**
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @param {string[]} trusted 锚点
+ * @param {string[]} roster 在线名册
+ * @param {() => number} rng 随机源
+ * @param {number} exploreCap explore 容量
+ * @param {boolean} [coldBootstrap=false] K=0 冷启动：不预填 explore
+ * @returns {Set<string>} 观察者可见 peer 集
+ */
+export function initObserverDiscovery(state, observerId, trusted, roster, rng, exploreCap = 8, coldBootstrap = false) {
+	state.trustedAnchorsByObserver.set(observerId, new Set(trusted))
+	const explore = new Set(trusted)
+	const pool = roster.filter(id => id !== observerId && !explore.has(id))
+	const minExplore = coldBootstrap
+		? 0
+		: trusted.length ? exploreCap : Math.max(exploreCap, 4)
+	while (explore.size < minExplore + trusted.length && pool.length) {
+		const i = Math.floor(rng() * pool.length)
+		explore.add(pool.splice(i, 1)[0])
+	}
+	state.exploreByObserver.set(observerId, explore)
+
+	const bucket = roomBucket(state, observerId)
+	for (const id of trusted) {
+		bucket.trustedReserved.add(id)
+		bucket.active.add(id)
+		bucket.sourceByPeer.set(id, 'trusted')
+	}
+	for (const id of explore) {
+		if (bucket.active.size >= state.rtcMaxActive) break
+		if (bucket.active.has(id)) continue
+		takeRoomSlot(state, observerId, id, 'explore', trusted)
+	}
+	return explore
+}
+
+/**
+ * K=0 冷启动：模拟 listVisible + connectToNode 填充 explore 槽。
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @param {string[]} roster 在线名册
+ * @param {() => number} rng 随机源
+ * @param {number} [batch=4] 每轮新增 explore 上限
+ * @returns {void}
+ */
+export function coldStartDiscoveryJoin(state, observerId, roster, rng, batch = 4) {
+	const trusted = [...observerTrustedAnchors(state, observerId)]
+	const explore = state.exploreByObserver.get(observerId) ?? new Set()
+	const pool = roster.filter(id => id !== observerId && !explore.has(id))
+	let added = 0
+	while (added < batch && pool.length) {
+		const i = Math.floor(rng() * pool.length)
+		const id = pool.splice(i, 1)[0]
+		explore.add(id)
+		takeRoomSlot(state, observerId, id, 'mesh:scan', trusted)
+		added++
+	}
+	state.exploreByObserver.set(observerId, explore)
+}
+
+/**
+ * 占用 RTC room 槽位；trusted 锚点优先保留，单源 explore 有配额。
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @param {string} peerId 对端
+ * @param {string} sourceId 来源标识
+ * @param {string[]} [trustedIds=[]] trusted 锚点
+ * @returns {boolean} 是否成功占槽
+ */
+export function takeRoomSlot(state, observerId, peerId, sourceId, trustedIds = []) {
+	const bucket = roomBucket(state, observerId)
+	if (bucket.active.has(peerId)) return true
+
+	const isTrusted = trustedIds.includes(peerId) || bucket.trustedReserved.has(peerId)
+	if (!isTrusted) {
+		const sourceCount = [...bucket.sourceByPeer.values()].filter(s => s === sourceId).length
+		if (sourceCount >= EXPLORE_MAX_PER_SOURCE) return false
+	}
+
+	const maxActive = state.rtcMaxActive
+	const trustedCount = bucket.trustedReserved.size
+	const nonTrustedActive = [...bucket.active].filter(id => !bucket.trustedReserved.has(id)).length
+	const maxNonTrusted = Math.max(0, maxActive - trustedCount)
+
+	if (!isTrusted && nonTrustedActive >= maxNonTrusted) return false
+
+	if (bucket.active.size >= maxActive && !isTrusted) return false
+
+	bucket.active.add(peerId)
+	bucket.sourceByPeer.set(peerId, sourceId)
+	if (isTrusted) bucket.trustedReserved.add(peerId)
+	return true
+}
+
+/**
+ * eclipse 攻击：Sybil 灌满 room 槽位并污染 explore。
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} victimObserverId 受害观察者
+ * @param {string} attackerId 攻击者
+ * @param {string[]} sybilIds 同簇 sybil
+ * @param {number} focus 填充强度 0..1
+ * @returns {void}
+ */
+export function eclipseFillExplore(state, victimObserverId, attackerId, sybilIds, focus = 0.7) {
+	const explore = state.exploreByObserver.get(victimObserverId) ?? new Set()
+	const cap = Math.max(2, Math.round(explore.size * focus))
+	let added = 0
+	const sybilSource = `eclipse:${attackerId}`
+	for (const id of [attackerId, ...sybilIds]) {
+		if (added >= cap) break
+		if (!explore.has(id)) {
+			explore.add(id)
+			added++
+		}
+		takeRoomSlot(state, victimObserverId, id, sybilSource, [...observerTrustedAnchors(state, victimObserverId)])
+	}
+	const poison = state.poisonedByAttacker.get(victimObserverId) ?? new Set()
+	poison.add(attackerId)
+	state.poisonedByAttacker.set(victimObserverId, poison)
+	state.exploreByObserver.set(victimObserverId, explore)
+}
+
+/**
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @param {string[]} friendlyIds 友善节点
+ * @param {(id: string) => number} scoreOf 信誉分
+ * @param {number} maxHop 最大跳
+ * @param {boolean} [ignorePoison=false] 反事实：忽略 poison/sybil 槽位污染
+ * @returns {number} 可达友善节点比例 0..1
+ */
+export function discoveryReach(state, observerId, friendlyIds, scoreOf, maxHop = 4, ignorePoison = false) {
+	const bucket = roomBucket(state, observerId)
+	const roomPeers = [...bucket.active].filter(id => friendlyIds.includes(id))
+	const anchorsSet = observerTrustedAnchors(state, observerId)
+	const explore = state.exploreByObserver.get(observerId) ?? anchorsSet
+	const anchors = [...anchorsSet].filter(id => friendlyIds.includes(id))
+	const adj = buildRankedNeighborAdj(friendlyIds, scoreOf, 6)
+	const start = new Set([...anchors, ...roomPeers, ...explore].filter(id => friendlyIds.includes(id)))
+	if (!start.size) return 0
+	const visited = new Set(start)
+	let frontier = [...start]
+	for (let hop = 0; hop < maxHop && frontier.length; hop++) {
+		const next = []
+		for (const id of frontier)
+			for (const peer of adj.get(id) ?? []) {
+				if (visited.has(peer)) continue
+				visited.add(peer)
+				next.push(peer)
+			}
+		frontier = next
+	}
+	const target = friendlyIds.filter(id => id !== observerId)
+	const rawReach = target.length ? [...visited].filter(id => target.includes(id)).length / target.length : 0
+	if (ignorePoison) return rawReach
+	const slotFill = bucket.active.size / Math.max(1, state.rtcMaxActive)
+	const sybilDominated = [...bucket.sourceByPeer.values()].filter(s => String(s).startsWith('eclipse:')).length
+	const sybilRatio = sybilDominated / Math.max(1, bucket.active.size)
+	return rawReach * Math.max(0.05, 1 - sybilRatio * 0.85) * Math.max(0.2, 1 - Math.max(0, slotFill - 0.75) * 2)
+}
+
+/**
+ * trusted 锚点恢复：清空 poison、释放非 trusted 槽位并重新注入锚点 explore。
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @returns {void}
+ */
+export function recoverDiscoveryFromAnchors(state, observerId) {
+	state.poisonedByAttacker.delete(observerId)
+	const keep = observerTrustedAnchors(state, observerId)
+	const priorExplore = state.exploreByObserver.get(observerId) ?? new Set()
+	const explore = new Set(keep)
+	for (const id of priorExplore)
+		if (!keep.has(id)) explore.add(id)
+	state.exploreByObserver.set(observerId, explore)
+	const bucket = roomBucket(state, observerId)
+	bucket.active = new Set(keep)
+	bucket.sourceByPeer = new Map([...keep].map(id => [id, 'trusted']))
+	bucket.trustedReserved = new Set(keep)
+	for (const id of explore) {
+		if (keep.has(id)) continue
+		takeRoomSlot(state, observerId, id, 'explore', [...keep])
+	}
+}
+
+/**
+ * @param {DiscoveryState} state 发现状态
+ * @param {string} observerId 观察者
+ * @returns {number} room 槽位占用率 0..1
+ */
+export function roomSlotFillRate(state, observerId) {
+	const bucket = state.roomSlotsByObserver.get(observerId)
+	if (!bucket) return 0
+	return bucket.active.size / Math.max(1, state.rtcMaxActive)
+}

package/sim/duration.mjs

@@ -0,0 +1,64 @@
+/**
+ * 墙钟时长解析（挖矿 `--duration`）。
+ */
+
+/**
+ * @param {string | boolean | undefined} raw CLI 原始值
+ * @returns {number | null} 毫秒；未指定或无效则 null
+ */
+export function parseDurationMs(raw) {
+	if (raw === undefined || raw === true || raw === '') return null
+	const text = String(raw).trim().toLowerCase()
+	if (!text) return null
+
+	const match = /^(\d+(?:\.\d+)?)(ms|s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours)?$/u.exec(text)
+	if (!match) return null
+
+	const value = Number(match[1])
+	if (!Number.isFinite(value) || value <= 0) return null
+
+	const unit = match[2] || 's'
+	switch (unit) {
+		case 'ms':
+			return Math.floor(value)
+		case 's':
+		case 'sec':
+		case 'secs':
+		case 'second':
+		case 'seconds':
+			return Math.floor(value * 1000)
+		case 'm':
+		case 'min':
+		case 'mins':
+		case 'minute':
+		case 'minutes':
+			return Math.floor(value * 60_000)
+		case 'h':
+		case 'hr':
+		case 'hrs':
+		case 'hour':
+		case 'hours':
+			return Math.floor(value * 3_600_000)
+		default:
+			return null
+	}
+}
+
+/**
+ * @param {number | null} durationMs 时长上限
+ * @param {number} [now=Date.now()] 当前时间
+ * @returns {number | null} 截止时间戳；无上限则 null
+ */
+export function deadlineFromDuration(durationMs, now = Date.now()) {
+	if (durationMs == null || durationMs <= 0) return null
+	return now + durationMs
+}
+
+/**
+ * @param {number | null} deadline 截止时间戳
+ * @param {number} [now=Date.now()] 当前时间
+ * @returns {boolean} 是否已到或超过截止（当前代结束后应停止）
+ */
+export function pastDeadline(deadline, now = Date.now()) {
+	return deadline != null && now >= deadline
+}

package/sim/graph_adj.mjs

@@ -0,0 +1,28 @@
+/**
+ * 按信誉分排序后的一次性邻接构建（避免每节点重复 sort）。
+ */
+
+/**
+ * @param {string[]} ids 参与构图的节点 id
+ * @param {(id: string) => number} scoreOf 信誉分
+ * @param {number} maxPeers 每节点最多邻居数
+ * @returns {Map<string, string[]>} id → 邻居 id 列表（按 scoreOf 降序取前 maxPeers）
+ */
+export function buildRankedNeighborAdj(ids, scoreOf, maxPeers) {
+	const scored = ids.map(id => ({ id, score: scoreOf(id) }))
+	scored.sort((a, b) => b.score - a.score)
+	const sorted = scored.map(s => s.id)
+	/** @type {Map<string, string[]>} */
+	const adj = new Map()
+	for (const id of ids) {
+		/** @type {string[]} */
+		const peers = []
+		for (const peer of sorted) {
+			if (peer === id) continue
+			peers.push(peer)
+			if (peers.length >= maxPeers) break
+		}
+		adj.set(id, peers)
+	}
+	return adj
+}

package/sim/integrity.mjs

@@ -0,0 +1,58 @@
+/**
+ * 密码学完整性 vs 主观信誉：持副本观察者独立证伪，无副本者才受信誉博弈影响。
+ */
+
+/**
+ * @param {import('./model.mjs').SimObserver} observer 观察者
+ * @param {import('./scenarios.mjs').SimScenario} scenario 场景
+ * @returns {boolean} 是否持有本地归档副本（可独立重算 digest）
+ */
+export function observerHasLocalReplica(observer, scenario) {
+	const groupSize = scenario.groupSize ?? 8
+	const honestShare = (scenario.honestCount ?? 0) / Math.max(1, groupSize)
+	const archiveHeavy = observer.trustedPeers.length >= 2
+		&& (scenario.behaviorDist?.archiveSubmitRate?.mean ?? 0) >= 0.15
+	return (honestShare >= 0.75 && observer.trustedPeers.length >= 1) || archiveHeavy
+}
+
+/**
+ * @param {import('./model.mjs').SimNode} attacker 攻击节点
+ * @param {import('./model.mjs').SimObserver} observer 观察者
+ * @param {import('./scenarios.mjs').SimScenario} scenario 场景
+ * @param {object} simulationContext 仿真上下文
+ * @returns {boolean} 完整性层是否已证伪该攻击（defense≈1）
+ */
+export function integrityDefendsAgainst(attacker, observer, scenario, simulationContext) {
+	if (!observerHasLocalReplica(observer, scenario)) return false
+	if (attacker.attack === 'equivocator') {
+		const key = `${attacker.id}:${observer.id}`
+		return (simulationContext.equivocationByObserver?.get(key) ?? 0) > 0
+	}
+	if (attacker.attack === 'archive_forger' || attacker.attack === 'lazy_chunk')
+		return simulationContext.verifiedForgeryByObserver?.get(observer.id)?.has(attacker.id) === true
+	return false
+}
+
+/**
+ * @param {import('./model.mjs').SimObserver[]} observers 观察者列表
+ * @param {import('./scenarios.mjs').SimScenario} scenario 场景
+ * @returns {number} 持副本观察者比例 0..1
+ */
+export function replicaObserverFraction(observers, scenario) {
+	if (!observers.length) return 0
+	let n = 0
+	for (const obs of observers)
+		if (observerHasLocalReplica(obs, scenario)) n++
+	return n / observers.length
+}
+
+/**
+ * 归档仲裁正确率：持副本者独立重算；无副本者走信誉 quorum。
+ * @param {number} quorumAccuracy 纯信誉 quorum 准确率
+ * @param {number} replicaFraction 持副本观察者比例
+ * @returns {number} 综合准确率
+ */
+export function blendArchiveQuorumAccuracy(quorumAccuracy, replicaFraction) {
+	const replicaBoost = replicaFraction * 0.85
+	return Math.max(quorumAccuracy, replicaBoost)
+}