@steve02081504/fount-p2p 0.0.21 → 0.0.23

package/core/entity_id.mjs

@@ -1,7 +1,6 @@
-import { Buffer } from 'node:buffer'
-
 import { pubKeyHash } from '../crypto/crypto.mjs'
 
+import { hexToBytes } from './bytes_codec.mjs'
 import {
 	encodeEntityHash,
 	ENTITY_HASH_RE,
@@ -26,9 +25,10 @@ export {
  */
 export function hashFromPubKeyHex(pubKeyHex) {
 	const hex = normalizeHex64(pubKeyHex)
-	if (!isHex64(hex) || Buffer.from(hex, 'hex').length !== 32)
-		throw new Error('invalid pubKeyHex')
-	return pubKeyHash(Buffer.from(hex, 'hex'))
+	if (!isHex64(hex)) throw new Error('invalid pubKeyHex')
+	const bytes = hexToBytes(hex)
+	if (bytes.length !== 32) throw new Error('invalid pubKeyHex')
+	return pubKeyHash(bytes)
 }
 
 /**

package/core/logical_entity.mjs

@@ -1,6 +1,6 @@
 import { sha256TextHex } from '../crypto/crypto.mjs'
 
-import { encodeEntityHash, parseEntityHash } from './entity_id.mjs'
+import { encodeEntityHash, parseEntityHash } from './entity_id_parse.mjs'
 
 /** @type {string} 逻辑实体 sentinel nodeHash（非物理节点绑定） */
 export const LOGICAL_ENTITY_SENTINEL_NODE_HASH = '0'.repeat(64)

package/core/random_id.mjs

@@ -1,9 +1,11 @@
-import { randomUUID } from 'node:crypto'
+/**
+ * 跨端随机 ID（Web Crypto / Node globalThis.crypto）。
+ */
 
 /**
  * @param {string} prefix ID 前缀（如 channel_）
  * @returns {string} 带前缀的随机 ID
  */
 export function prefixedRandomId(prefix) {
-	return `${prefix}${randomUUID().replace(/-/g, '')}`
+	return `${prefix}${globalThis.crypto.randomUUID().replace(/-/g, '')}`
 }

package/crypto/crypto.mjs

@@ -1,105 +1,65 @@
-import { Buffer } from 'node:buffer'
-import {
-	createHash,
-	createPrivateKey,
-	createPublicKey,
-	randomBytes,
-	sign as nodeSign,
-	verify as nodeVerify,
-} from 'node:crypto'
-
-/** 固定 DER 头（非秘密），让 Node 把 32 字节种子当成私钥 */
-const PKCS8_RAW_SEED_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex')
-/** 固定 DER 头（非秘密），让 Node 把 32 字节当成公钥 */
-const SPKI_RAW_PUB_PREFIX = Buffer.from('302a300506032b6570032100', 'hex')
-
 /**
- * @param {Uint8Array|Buffer} seed32 32 字节私钥种子
- * @returns {import('node:crypto').KeyObject} Node 私钥对象
+ * 跨端 Ed25519 / SHA-256（Node 与浏览器共用；不依赖 node:crypto）。
  */
-function privateKeyFromSeed(seed32) {
-	return createPrivateKey({
-		key: Buffer.concat([PKCS8_RAW_SEED_PREFIX, Buffer.from(seed32).subarray(0, 32)]),
-		format: 'der',
-		type: 'pkcs8',
-	})
-}
+import { ed25519 } from '@noble/curves/ed25519.js'
+import { sha256 } from '@noble/hashes/sha2.js'
 
-/**
- * @param {Uint8Array|Buffer} rawPublicKey 32 字节公钥
- * @returns {import('node:crypto').KeyObject} Node 公钥对象
- */
-function publicKeyFromRaw(rawPublicKey) {
-	return createPublicKey({
-		key: Buffer.concat([SPKI_RAW_PUB_PREFIX, Buffer.from(rawPublicKey).subarray(0, 32)]),
-		format: 'der',
-		type: 'spki',
-	})
-}
+import { bytesToHex, toBytes } from '../core/bytes_codec.mjs'
 
 /**
- * @param {Uint8Array|Buffer} seed32 32 字节私钥种子
- * @returns {Uint8Array} 32 字节公钥
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer|string} data 字节或 UTF-8 文本
+ * @returns {Uint8Array} 规范化字节
  */
-function rawPublicKeyFromSeed(seed32) {
-	const der = createPublicKey(privateKeyFromSeed(seed32)).export({ type: 'spki', format: 'der' })
-	return new Uint8Array(der.subarray(-32))
+function inputBytes(data) {
+	if (typeof data === 'string') return new TextEncoder().encode(data)
+	return toBytes(data)
 }
 
 /**
- * 由种子字节派生密钥对
- *
- * @param {Uint8Array|Buffer} seed 任意长度；非 32 字节时 sha256 派生
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer} seed 任意长度；非 32 字节时 sha256 派生
  * @returns {{ publicKey: Uint8Array, secretKey: Uint8Array }} 32 字节私钥与对应公钥
  */
 export function keyPairFromSeed(seed) {
-	const u = seed instanceof Uint8Array ? seed : new Uint8Array(seed)
-	const sk = u.length === 32 ? u : new Uint8Array(createHash('sha256').update(u).digest())
-	return { publicKey: rawPublicKeyFromSeed(sk), secretKey: new Uint8Array(sk) }
+	const u = toBytes(seed)
+	const sk = u.length === 32 ? u : sha256(u)
+	return { publicKey: ed25519.getPublicKey(sk), secretKey: new Uint8Array(sk) }
 }
 
 /**
- * 随机生成密钥对
- *
  * @returns {Promise<{ publicKey: Uint8Array, secretKey: Uint8Array }>} 随机密钥对
  */
 export async function randomKeyPair() {
-	const sk = randomBytes(32)
+	const sk = new Uint8Array(32)
+	globalThis.crypto.getRandomValues(sk)
 	return keyPairFromSeed(sk)
 }
 
 /**
- * 由 32 字节私钥种子导出对应公钥
  * @param {Uint8Array} secretKey 私钥种子
  * @returns {Uint8Array} 公钥
  */
 export function publicKeyFromSeed(secretKey) {
-	return rawPublicKeyFromSeed(secretKey)
+	return ed25519.getPublicKey(toBytes(secretKey).subarray(0, 32))
 }
 
 /**
- * 签名
- *
- * @param {Uint8Array} message 待签名消息字节
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer|string} message 待签名消息
  * @param {Uint8Array} secretKey 私钥（取前 32 字节为种子）
  * @returns {Promise<Uint8Array>} 64 字节签名
  */
 export async function sign(message, secretKey) {
-	const sig = nodeSign(null, Buffer.from(message), privateKeyFromSeed(secretKey))
-	return new Uint8Array(sig)
+	return ed25519.sign(inputBytes(message), toBytes(secretKey).subarray(0, 32))
 }
 
 /**
- * 校验签名
- *
- * @param {Uint8Array} signature 64 字节签名
- * @param {Uint8Array} message 原始消息字节
- * @param {Uint8Array} publicKey 公钥
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer} signature 64 字节签名
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer|string} message 原始消息
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer} publicKey 公钥
  * @returns {Promise<boolean>} 合法为 true；异常或失败为 false
  */
 export async function verify(signature, message, publicKey) {
 	try {
-		return nodeVerify(null, Buffer.from(message), publicKeyFromRaw(publicKey), Buffer.from(signature))
+		return ed25519.verify(toBytes(signature), inputBytes(message), toBytes(publicKey))
 	}
 	catch {
 		return false
@@ -107,52 +67,25 @@ export async function verify(signature, message, publicKey) {
 }
 
 /**
- * 公钥的 sha256 十六进制指纹（小写、无 0x 前缀）
- *
- * @param {Uint8Array} publicKey 公钥字节
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer} publicKey 公钥字节
  * @returns {string} 64 字符 hex
  */
 export function pubKeyHash(publicKey) {
-	return bufferToHexSimple(hashPubKeyBytes(publicKey))
-}
-
-/**
- * 公钥 sha256 摘要
- *
- * @param {Uint8Array} publicKey 公钥字节
- * @returns {Buffer} 32 字节 digest
- */
-function hashPubKeyBytes(publicKey) {
-	return createHash('sha256').update(publicKey).digest()
+	return bytesToHex(sha256(toBytes(publicKey)))
 }
 
 /**
- * 任意输入的 SHA-256 十六进制（小写、无 0x 前缀）。
- *
- * @param {Uint8Array|Buffer|string} data 字节或 UTF-8 文本
+ * @param {Uint8Array|ArrayBufferView|ArrayBuffer|string} data 字节或 UTF-8 文本
  * @returns {string} 64 字符 hex
  */
 export function sha256Hex(data) {
-	const input = typeof data === 'string' ? Buffer.from(data, 'utf8') : Buffer.from(data)
-	return createHash('sha256').update(input).digest('hex')
+	return bytesToHex(sha256(inputBytes(data)))
 }
 
 /**
- * UTF-8 文本 SHA-256 十六进制（小写、无 0x 前缀）。
- *
  * @param {string} text 文本
  * @returns {string} 64 字符 hex
  */
 export function sha256TextHex(text) {
 	return sha256Hex(String(text ?? ''))
 }
-
-/**
- * Buffer / Uint8Array → 小写 hex 字符串
- *
- * @param {Uint8Array|Buffer} buffer 二进制缓冲
- * @returns {string} 小写十六进制文本
- */
-function bufferToHexSimple(buffer) {
-	return Buffer.from(buffer).toString('hex')
-}

package/files/manifest_fetch.mjs

@@ -26,8 +26,8 @@ const manifestInflight = createInflightTable({
 
 /**
  * 拉取公开 manifest；默认不写盘。`cache: true` 或 `cachePublicManifest` 才缓存。
- * 本地已有 publicSig 时仍会 fanout 再校验，按 publishedAt 择新；超时则回退本地。
- * 同 key in-flight 去重；调用方外层超时不 abort，后台继续填缓存。
+ * 本地已有 publicSig 时立即返回，并后台 fanout；`cache: true` 时按 publishedAt 择新写盘。
+ * 冷 miss 仍等 fanout。同 key in-flight 去重；调用方外层超时不 abort，后台继续填缓存。
  * @param {{ username: string, ownerEntityHash: string, logicalPath: string, cache?: boolean, timeoutMs?: number }} context - 拉取上下文
  * @returns {Promise<import('./manifest.mjs').FileManifest | null>} 验签后的 manifest，失败为 null
  */
@@ -42,6 +42,7 @@ export async function fetchPublicManifest(context) {
 		: DEFAULT_MANIFEST_FETCH_TIMEOUT_MS
 	const expectedKey = manifestFetchExpectedKey(ownerEntityHash, logicalPath)
 	const inflightKey = `${username}\0${expectedKey}`
+	const wantCache = context.cache === true
 
 	// 先挂 in-flight（同步），再读本地 — 避免并发调用在 await 间隙各自 start
 	const localPromise = loadFileManifest(ownerEntityHash, logicalPath)
@@ -67,15 +68,21 @@ export async function fetchPublicManifest(context) {
 	const hasLocalPublic = local?.transferKeyDescriptor?.type === 'public' && !!local?.meta?.publicSig
 	if (!shared) return hasLocalPublic ? local : null
 
-	const result = await shared
-
-	if (result && (!hasLocalPublic || shouldPreferIncomingPublicManifest(local, result))) {
-		if (context.cache === true)
-			await cachePublicManifest(ownerEntityHash, logicalPath, result)
-		return result
+	if (hasLocalPublic) {
+		// SWR：立刻回本地；后台 fanout 择新写盘（需 cache: true）
+		if (wantCache) {
+			void shared.then(async result => {
+				if (result && shouldPreferIncomingPublicManifest(local, result))
+					await cachePublicManifest(ownerEntityHash, logicalPath, result)
+			})
+		}
+		return local
 	}
-	if (hasLocalPublic) return local
-	return null
+
+	const result = await shared
+	if (!result) return null
+	if (wantCache) await cachePublicManifest(ownerEntityHash, logicalPath, result)
+	return result
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@steve02081504/fount-p2p",
-	"version": "0.0.21",
+	"version": "0.0.23",
 	"description": "fount federation P2P layer — link, trust graph, mailbox, DAG, EVFS.",
 	"keywords": [
 		"network",
@@ -71,6 +71,7 @@
 	},
 	"dependencies": {
 		"@noble/curves": "latest",
+		"@noble/hashes": "latest",
 		"node-rtc-connection": "latest",
 		"on-shutdown": "latest",
 		"ws": "latest"