@steve02081504/fount-p2p 0.0.0

package/node/denylist.mjs

@@ -0,0 +1,309 @@
+import { compositeKey } from '../core/composite_key.mjs'
+import { isEntityHash128 } from '../core/entity_id.mjs'
+import { isHex64, normalizeHex64 } from '../core/hexIds.mjs'
+import { withAsyncMutex } from '../utils/async_mutex.mjs'
+
+import { readNodeJsonSync, writeNodeJsonSync } from './storage.mjs'
+
+const DATA_NAME = 'denylist'
+
+/** @typedef {'subject' | 'entity' | 'node'} DenyScope — 节点连接拒绝（deny），非 Social block / 群 ban */
+
+/**
+ * @typedef {{
+ *   blocked: Array<{ scope: DenyScope, value: string, groupId?: string }>
+ *   keys: Set<string>
+ * }} DenylistIndex
+ */
+
+/** @type {DenylistIndex | null} */
+let cachedIndex = null
+
+/**
+ * 串行化 denylist 写路径，避免并发 load/save 覆写。
+ * @param {() => void | Promise<void>} mutator 突变
+ * @returns {Promise<void>}
+ */
+function mutateDenylist(mutator) {
+	return withAsyncMutex('denylist', mutator)
+}
+
+/**
+ * @param {DenyScope} scope 拉黑范围
+ * @param {string} groupId 群 ID 或 `*`
+ * @param {string} value 键值
+ * @returns {string} 索引键
+ */
+function denyKey(scope, groupId, value) {
+	return compositeKey(scope, groupId, value)
+}
+
+/**
+ * @param {Array<{ scope: DenyScope, value: string, groupId?: string }>} blocked 条目
+ * @returns {DenylistIndex} 内存索引
+ */
+function buildDenylistIndex(blocked) {
+	/** @type {DenylistIndex} */
+	const index = { blocked, keys: new Set() }
+	for (const entry of blocked) {
+		const gid = String(entry.groupId || '').trim() || '*'
+		if (entry.scope === 'entity') {
+			index.keys.add(denyKey('entity', '*', entry.value))
+			continue
+		}
+		index.keys.add(denyKey(entry.scope, gid, entry.value))
+	}
+	return index
+}
+
+/**
+ * @returns {void}
+ */
+export function invalidateDenylistIndex() {
+	cachedIndex = null
+}
+
+/**
+ * @returns {DenylistIndex} 缓存索引
+ */
+function getDenylistIndex() {
+	if (cachedIndex) return cachedIndex
+	const raw = readNodeJsonSync(DATA_NAME)
+	const blocked = normalizeDenylist(raw).blocked
+	cachedIndex = buildDenylistIndex(blocked)
+	return cachedIndex
+}
+
+/**
+ * @param {unknown} raw 磁盘 JSON 或请求体
+ * @returns {{ blocked: Array<{ scope: DenyScope, value: string, groupId?: string }> }} 规范化 denylist
+ */
+export function normalizeDenylist(raw) {
+	/** @type {Array<{ scope: DenyScope, value: string, groupId?: string }>} */
+	const blocked = []
+	for (const entry of raw?.blocked || []) {
+		const scope = String(entry?.scope || '').trim().toLowerCase()
+		const value = String(entry?.value || '').trim().toLowerCase()
+		const groupId = String(entry.groupId || '').trim()
+		if (!scope || !value) continue
+		if (scope === 'entity') {
+			if (isEntityHash128(value))
+				blocked.push({ scope: 'entity', value })
+			continue
+		}
+		if (scope === 'node' && isHex64(normalizeHex64(value)))
+			blocked.push({ scope: 'node', value: normalizeHex64(value), ...groupId ? { groupId } : {} })
+		else if (scope === 'subject' && isHex64(normalizeHex64(value)))
+			blocked.push({ scope: 'subject', value: normalizeHex64(value), ...groupId ? { groupId } : {} })
+	}
+	return { blocked }
+}
+
+/**
+ * @returns {{ blocked: Array<{ scope: DenyScope, value: string, groupId?: string }> }} 节点级 denylist
+ */
+export function loadDenylist() {
+	return { blocked: getDenylistIndex().blocked }
+}
+
+/**
+ * @param {{ blocked: Array<{ scope: DenyScope, value: string, groupId?: string }> }} list denylist
+ * @returns {void}
+ */
+export function saveDenylist(list) {
+	const blocked = normalizeDenylist(list).blocked
+	writeNodeJsonSync(DATA_NAME, { blocked })
+	cachedIndex = buildDenylistIndex(blocked)
+}
+
+/**
+ * @param {object} state 物化群状态
+ * @param {object} subject 待检主体
+ * @returns {boolean} 是否命中群级 ban 集合
+ */
+export function isSubjectBannedByState(state, subject) {
+	const pk = normalizeHex64(subject?.pubKeyHash)
+	if (isHex64(pk) && state?.bannedMembers?.has?.(pk)) return true
+	const entity = String(subject?.entityHash || '').trim().toLowerCase()
+	if (isEntityHash128(entity) && state?.bannedEntities?.has?.(entity)) return true
+	const node = normalizeHex64(subject?.nodeHash)
+	if (isHex64(node) && state?.bannedNodes?.has?.(node)) return true
+	return false
+}
+
+/**
+ * @param {DenylistIndex} index 内存索引
+ * @param {object} subject 待检主体
+ * @param {string} [groupId] 可选群 scope
+ * @returns {boolean} 是否命中
+ */
+function matchesDenylistIndex(index, subject, groupId = '') {
+	const pk = normalizeHex64(subject?.pubKeyHash)
+	const entity = String(subject?.entityHash || '').trim().toLowerCase()
+	const node = normalizeHex64(subject?.nodeHash)
+	const gid = String(groupId || '').trim()
+	const { keys } = index
+
+	if (entity && keys.has(denyKey('entity', '*', entity))) return true
+	if (isHex64(node) && keys.has(denyKey('node', '*', node))) return true
+	if (isHex64(pk) && keys.has(denyKey('subject', '*', pk))) return true
+	if (!gid) return false
+	if (isHex64(pk) && keys.has(denyKey('subject', gid, pk))) return true
+	if (isHex64(node) && keys.has(denyKey('node', gid, node))) return true
+	return false
+}
+
+/**
+ * @param {object} subject 待检主体
+ * @param {string} [groupId] 可选群 scope
+ * @returns {boolean} 是否在节点级 denylist 中（deny，非 Social block）
+ */
+export function isSubjectBlocked(subject, groupId = '') {
+	return matchesDenylistIndex(getDenylistIndex(), subject, groupId)
+}
+
+/**
+ * @param {string} groupId 群 ID
+ * @param {string} peerKey pubKeyHash 或 nodeHash（按 scope 分别匹配，不混填）
+ * @returns {boolean} 是否拉黑
+ */
+export function isPeerKeyBlocked(groupId, peerKey) {
+	const key = normalizeHex64(peerKey)
+	if (!isHex64(key)) return false
+	const index = getDenylistIndex()
+	const gid = String(groupId || '').trim()
+	const { keys } = index
+	if (keys.has(denyKey('subject', '*', key))) return true
+	if (keys.has(denyKey('node', '*', key))) return true
+	if (!gid) return false
+	if (keys.has(denyKey('subject', gid, key))) return true
+	if (keys.has(denyKey('node', gid, key))) return true
+	return false
+}
+
+/**
+ * @param {string} pubKeyHash 64 位十六进制
+ * @returns {boolean} 是否拉黑该 subject
+ */
+export function isPubKeyHashBlocked(pubKeyHash) {
+	return isSubjectBlocked({ pubKeyHash })
+}
+
+/**
+ * @param {string} entityHash 128 位十六进制
+ * @returns {boolean} 是否拉黑该 entity
+ */
+export function isEntityHashBlocked(entityHash) {
+	return isSubjectBlocked({ entityHash })
+}
+
+/**
+ * 追加拉黑并落盘。
+ * @param {{ scope: DenyScope, value: string, groupId?: string }} entry 拉黑项
+ * @returns {Promise<void>}
+ */
+export function addDenylistEntry(entry) {
+	const scope = String(entry?.scope || '').trim().toLowerCase()
+	const value = String(entry?.value || '').trim().toLowerCase()
+	if (!scope || !value)
+		throw new Error('scope and value required')
+	if (scope === 'entity' && entry.groupId)
+		throw new Error('entity scope does not use groupId')
+	if (scope === 'subject' && !isHex64(normalizeHex64(value)))
+		throw new Error('invalid pubKeyHash')
+	if (scope === 'entity' && !isEntityHash128(value))
+		throw new Error('invalid entityHash')
+	if (scope === 'node' && !isHex64(normalizeHex64(value)))
+		throw new Error('invalid nodeHash')
+
+	const normValue = scope === 'node' || scope === 'subject' ? normalizeHex64(value) : value
+	const groupId = entry.groupId ? String(entry.groupId).trim() : undefined
+	return mutateDenylist(() => {
+		const list = loadDenylist()
+		if (list.blocked.some(row => row.scope === scope && row.value === normValue && row.groupId === groupId))
+			return
+		list.blocked.push(groupId ? { scope, value: normValue, groupId } : { scope, value: normValue })
+		saveDenylist(list)
+	})
+}
+
+/**
+ * @param {object} banContent member_ban 内容
+ * @param {string} [groupId] 来源群
+ * @returns {Promise<void>}
+ */
+export async function addDenylistFromBanContent(banContent, groupId) {
+	const scope = String(banContent?.banScope || 'entity').trim().toLowerCase()
+	const sourceGroupId = String(groupId || '').trim()
+	if (scope === 'entity' && banContent?.targetEntityHash)
+		await addDenylistEntry({ scope: 'entity', value: banContent.targetEntityHash })
+	if (scope === 'node' && banContent?.targetNodeHash)
+		await addDenylistEntry({ scope: 'node', value: banContent.targetNodeHash })
+	const pk = normalizeHex64(banContent?.targetPubKeyHash)
+	if (isHex64(pk))
+		await addDenylistEntry({ scope: 'subject', value: pk, ...sourceGroupId ? { groupId: sourceGroupId } : {} })
+}
+
+/**
+ * @param {string} entityHash 128 位十六进制
+ * @param {boolean} block true=拉黑
+ * @returns {Promise<boolean>} 当前是否拉黑
+ */
+export async function setEntityBlocked(entityHash, block) {
+	const id = String(entityHash || '').trim().toLowerCase()
+	if (!isEntityHash128(id)) throw new Error('invalid entityHash')
+	await mutateDenylist(() => {
+		const list = loadDenylist()
+		const without = list.blocked.filter(e => !(e.scope === 'entity' && e.value === id))
+		if (block) without.push({ scope: 'entity', value: id })
+		saveDenylist({ blocked: without })
+	})
+	return block
+}
+
+/**
+ * 追加群 scope 拉黑项。
+ * @param {string} groupId 群 ID
+ * @param {DenyScope} scope subject | entity | node 作用域
+ * @param {string} value 键值
+ * @returns {Promise<void>}
+ */
+export function addGroupBlockedPeer(groupId, scope, value) {
+	const normScope = String(scope || '').trim().toLowerCase()
+	if (normScope === 'entity')
+		return addDenylistEntry({ scope: normScope, value })
+	return addDenylistEntry({ scope: normScope, value, groupId })
+}
+
+/**
+ * @param {string} groupId 群 ID
+ * @param {DenyScope} scope subject | entity | node 作用域
+ * @param {string} value 键值
+ * @returns {Promise<void>}
+ */
+export function removeGroupBlockedPeer(groupId, scope, value) {
+	const normScope = String(scope || '').trim().toLowerCase()
+	const id = String(value || '').trim().toLowerCase()
+	if (!normScope || !id) return Promise.resolve()
+	return mutateDenylist(() => {
+		const list = loadDenylist()
+		list.blocked = list.blocked.filter(entry => {
+			if (entry.scope !== normScope || entry.value !== id) return true
+			if (normScope === 'entity') return false
+			return entry.groupId !== groupId
+		})
+		saveDenylist(list)
+	})
+}
+
+/**
+ * @param {string} groupId 群 ID
+ * @param {Array<{ scope: DenyScope, value: string }>} entries 拉黑条目
+ * @returns {Promise<void>}
+ */
+export async function addGroupBlockedPeers(groupId, entries) {
+	for (const entry of entries) {
+		if (!entry?.scope || !entry?.value) continue
+		await addGroupBlockedPeer(groupId, entry.scope, entry.value)
+	}
+}

package/node/entity_store.mjs

@@ -0,0 +1,214 @@
+import { Buffer } from 'node:buffer'
+import fsp from 'node:fs/promises'
+import path from 'node:path'
+
+import { parseEntityHash } from '../core/entity_id.mjs'
+import { assertSafeEvfsLogicalPath } from '../core/evfs_logical_path.mjs'
+import { readJsonFile, writeJsonFile } from '../utils/json_io.mjs'
+
+/**
+ * @typedef {object} EntityStore
+ * @property {(entityHash: string) => Promise<string[]>} listEntityFiles 列出逻辑路径
+ * @property {(entityHash: string, logicalPath: string) => Promise<Buffer | null>} readEntityFile
+ * @property {(entityHash: string, logicalPath: string, data: Buffer | Uint8Array) => Promise<void>} writeEntityFile
+ * @property {(entityHash: string, logicalPath: string) => Promise<boolean>} statEntityFile
+ * @property {(entityHash: string, name: string) => Promise<object | null>} readEntityJson
+ * @property {(entityHash: string, name: string, data: object) => Promise<void>} writeEntityJson
+ * @property {(entityHash: string, logicalPath: string) => Promise<object | null>} readManifest
+ * @property {(entityHash: string, logicalPath: string, data: object) => Promise<void>} writeManifest
+ * @property {(entityHash: string, logicalPath: string) => Promise<boolean>} statManifest
+ * @property {() => Promise<string[]>} listEntityHashes
+ */
+
+/**
+ * @param {string} entityHash 128 位十六进制
+ * @returns {string} 规范化 entityHash
+ */
+function normalizeEntityHash(entityHash) {
+	const hash = String(entityHash || '').trim().toLowerCase()
+	if (!parseEntityHash(hash)) throw new Error('invalid entityHash')
+	return hash
+}
+
+/**
+ * @param {string} baseDir entities 根目录
+ * @returns {EntityStore} 默认文件系统 EntityStore
+ */
+export function createFsEntityStore(baseDir) {
+	const root = path.resolve(baseDir)
+
+	/**
+	 * @param {string} entityHash 128 位十六进制
+	 * @returns {string} 实体目录绝对路径
+	 */
+	function entityRoot(entityHash) {
+		return path.join(root, normalizeEntityHash(entityHash))
+	}
+
+	/**
+	 * @param {string} entityHash 128 位十六进制
+	 * @param {string} name 相对文件名（如 profile.json）
+	 * @returns {string} JSON 文件绝对路径
+	 */
+	function entityJsonPath(entityHash, name) {
+		const safe = String(name || '').trim().replace(/\\/g, '/')
+		if (!safe || safe.includes('..') || safe.startsWith('/')) throw new Error('invalid entity json name')
+		return path.join(entityRoot(entityHash), safe)
+	}
+
+	/**
+	 * @param {string} entityHash 128 位十六进制
+	 * @param {string} logicalPath EVFS 逻辑路径
+	 * @returns {string} manifest 绝对路径
+	 */
+	function manifestPath(entityHash, logicalPath) {
+		const filesRoot = path.join(entityRoot(entityHash), 'files')
+		const safe = assertSafeEvfsLogicalPath(logicalPath)
+		const resolved = path.resolve(filesRoot, `${safe}.manifest.json`)
+		const rootResolved = path.resolve(filesRoot)
+		if (resolved !== rootResolved && !resolved.startsWith(rootResolved + path.sep))
+			throw new Error('invalid EVFS path traversal')
+		return resolved
+	}
+
+	return {
+		/**
+		 * @returns {Promise<string[]>} 本 store 下全部 entityHash
+		 */
+		async listEntityHashes() {
+			try {
+				const entries = await fsp.readdir(root, { withFileTypes: true })
+				return entries.filter(e => e.isDirectory()).map(e => e.name.toLowerCase()).filter(h => parseEntityHash(h))
+			}
+			catch (err) {
+				if (/** @type {NodeJS.ErrnoException} */ err.code === 'ENOENT') return []
+				throw err
+			}
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} name 相对 JSON 名
+		 * @returns {Promise<object | null>} 解析后的 JSON 或 null
+		 */
+		async readEntityJson(entityHash, name) {
+			return readJsonFile(entityJsonPath(entityHash, name))
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} name 相对 JSON 名
+		 * @param {object} data 写入对象
+		 * @returns {Promise<void>}
+		 */
+		async writeEntityJson(entityHash, name, data) {
+			await writeJsonFile(entityJsonPath(entityHash, name), data)
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @returns {Promise<Buffer | null>} 明文文件或 null
+		 */
+		async readEntityFile(entityHash, logicalPath) {
+			const filePath = manifestPath(entityHash, logicalPath).replace(/\.manifest\.json$/u, '')
+			try {
+				return await fsp.readFile(filePath)
+			}
+			catch (err) {
+				if (/** @type {NodeJS.ErrnoException} */ err.code === 'ENOENT') return null
+				throw err
+			}
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @param {Buffer | Uint8Array} data 明文内容
+		 * @returns {Promise<void>}
+		 */
+		async writeEntityFile(entityHash, logicalPath, data) {
+			const filePath = manifestPath(entityHash, logicalPath).replace(/\.manifest\.json$/u, '')
+			await fsp.mkdir(path.dirname(filePath), { recursive: true })
+			await fsp.writeFile(filePath, Buffer.from(data))
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @returns {Promise<boolean>} 明文文件是否存在
+		 */
+		async statEntityFile(entityHash, logicalPath) {
+			const filePath = manifestPath(entityHash, logicalPath).replace(/\.manifest\.json$/u, '')
+			try {
+				await fsp.access(filePath)
+				return true
+			}
+			catch {
+				return false
+			}
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @returns {Promise<string[]>} 逻辑路径列表
+		 */
+		async listEntityFiles(entityHash) {
+			const filesRoot = path.join(entityRoot(entityHash), 'files')
+			/** @type {string[]} */
+			const out = []
+			/**
+			 * @param {string} dir 当前目录
+			 * @param {string} prefix 相对前缀
+			 * @returns {Promise<void>}
+			 */
+			async function walk(dir, prefix) {
+				let entries
+				try { entries = await fsp.readdir(dir, { withFileTypes: true }) }
+				catch { return }
+				for (const entry of entries) {
+					const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+					if (entry.isDirectory()) await walk(path.join(dir, entry.name), rel)
+					else if (entry.name.endsWith('.manifest.json'))
+						out.push(rel.replace(/\.manifest\.json$/u, ''))
+				}
+			}
+			await walk(filesRoot, '')
+			return out
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @returns {Promise<object | null>} manifest 或 null
+		 */
+		async readManifest(entityHash, logicalPath) {
+			return readJsonFile(manifestPath(entityHash, logicalPath))
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @param {object} data manifest 对象
+		 * @returns {Promise<void>}
+		 */
+		async writeManifest(entityHash, logicalPath, data) {
+			await writeJsonFile(manifestPath(entityHash, logicalPath), data)
+		},
+
+		/**
+		 * @param {string} entityHash 128 位十六进制
+		 * @param {string} logicalPath EVFS 逻辑路径
+		 * @returns {Promise<boolean>} manifest 是否存在
+		 */
+		async statManifest(entityHash, logicalPath) {
+			try {
+				await fsp.access(manifestPath(entityHash, logicalPath))
+				return true
+			}
+			catch {
+				return false
+			}
+		},
+	}
+}

package/node/identity.mjs

@@ -0,0 +1,99 @@
+import { randomBytes } from 'node:crypto'
+
+import { userEntityHashFromRecoveryPubKeyHex } from '../core/entity_id.mjs'
+import { isHex64 } from '../core/hexIds.mjs'
+import { nodeHashFromSeed } from '../entity/node_hash.mjs'
+import { normalizeMailboxSettings } from '../mailbox/settings.mjs'
+
+import { emitNodeChange } from './instance.mjs'
+import { readNodeJsonSync, writeNodeJsonSync } from './storage.mjs'
+
+const NODE_SEED_HEX_RE = /^[0-9a-f]{64}$/iu
+const NODE_JSON = 'node'
+
+/**
+ * @returns {object} 节点配置磁盘对象
+ */
+function loadNodeFile() {
+	return readNodeJsonSync(NODE_JSON) || {}
+}
+
+/**
+ * @param {object} patch 部分字段
+ * @returns {object} 合并后写盘
+ */
+function saveNodeFile(patch) {
+	const data = { ...loadNodeFile(), ...patch }
+	writeNodeJsonSync(NODE_JSON, data)
+	emitNodeChange('node-config-changed', { patch })
+	return data
+}
+
+/**
+ * @returns {string} 64 位十六进制 节点种子
+ */
+export function ensureNodeSeed() {
+	const data = loadNodeFile()
+	const existing = String(data.nodeSeedHex || '').trim().toLowerCase()
+	if (NODE_SEED_HEX_RE.test(existing)) return existing
+	const nodeSeedHex = randomBytes(32).toString('hex')
+	saveNodeFile({ nodeSeedHex })
+	return nodeSeedHex
+}
+
+/**
+ * @returns {string} 本节点 64 hex nodeHash
+ */
+export function getNodeHash() {
+	return nodeHashFromSeed(ensureNodeSeed())
+}
+
+/**
+ * @returns {{ relayUrls: string[], batterySaver: boolean, mailbox: ReturnType<typeof normalizeMailboxSettings> }} 传输与 mailbox 配置
+ */
+export function getNodeTransportSettings() {
+	const data = loadNodeFile()
+	const relayUrls = Array.isArray(data.relayUrls)
+		? data.relayUrls.map(url => String(url).trim()).filter(url => url.startsWith('wss://'))
+		: []
+	const batterySaver = !!data.batterySaver
+	const mailbox = normalizeMailboxSettings(data.mailbox || {})
+	return { relayUrls, batterySaver, mailbox }
+}
+
+/**
+ * @param {object} patch 部分字段
+ * @returns {ReturnType<typeof getNodeTransportSettings>} 保存后的传输配置
+ */
+export function saveNodeTransportSettings(patch) {
+	const data = loadNodeFile()
+	if (patch.batterySaver != null) data.batterySaver = !!patch.batterySaver
+	if (patch.relayUrls)
+		data.relayUrls = patch.relayUrls.map(url => String(url).trim()).filter(url => url.startsWith('wss://'))
+	if (patch.mailbox)
+		data.mailbox = normalizeMailboxSettings({ ...data.mailbox, ...patch.mailbox })
+	saveNodeFile(data)
+	return getNodeTransportSettings()
+}
+
+/**
+ * 确保 node.json 存在且含 nodeSeed、mailbox 默认值。
+ * @returns {ReturnType<typeof getNodeTransportSettings> & { nodeHash: string }} 默认配置与 nodeHash
+ */
+export function ensureNodeDefaults() {
+	ensureNodeSeed()
+	const data = loadNodeFile()
+	if (!data.mailbox) saveNodeFile({ mailbox: normalizeMailboxSettings({}) })
+	return { ...getNodeTransportSettings(), nodeHash: getNodeHash() }
+}
+
+/**
+ * @param {string} nodeHash 64 位十六进制
+ * @param {string} recoveryPubKeyHex 64 位十六进制 recovery 公钥（稳定身份锚）
+ * @returns {string | null} 操作者 entityHash
+ */
+export function operatorEntityHashFromKeys(nodeHash, recoveryPubKeyHex) {
+	const pub = String(recoveryPubKeyHex || '').trim().toLowerCase().replace(/^0x/iu, '')
+	if (!isHex64(nodeHash) || !isHex64(pub)) return null
+	return userEntityHashFromRecoveryPubKeyHex(nodeHash, pub)
+}