libp2r2p 0.11.36 → 0.12.1

package/key/helpers/core.js

@@ -0,0 +1,149 @@
+import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js'
+
+import { bytesToHex, hexToBytes } from '../../base16/index.js'
+import { ValidationError } from '../../error/index.js'
+import { finalizeEvent } from '../../event/js/index.js'
+import { nsecDecode, nsecEncode, npubDecode, npubEncode } from '../../nip19/index.js'
+
+const HEX_SECKEY_REGEX = /^[0-9a-f]{64}$/i
+
+export function validateSecretKey (secretKey) {
+  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32 || !secp256k1.utils.isValidSecretKey(secretKey)) {
+    throw new ValidationError('INVALID_SECRET_KEY')
+  }
+}
+
+export function generateSecretKey () {
+  return schnorr.utils.randomSecretKey()
+}
+
+export function getPublicKey (secretKey) {
+  validateSecretKey(secretKey)
+  return bytesToHex(schnorr.getPublicKey(secretKey))
+}
+
+export function keypairFromSecretKey (secretKey, pubkey) {
+  return {
+    secretKey,
+    seckey: bytesToHex(secretKey),
+    pubkey,
+    nsec: nsecEncode(bytesToHex(secretKey)),
+    npub: npubEncode(pubkey)
+  }
+}
+
+export function generateKeypair () {
+  const secretKey = generateSecretKey()
+  return keypairFromSecretKey(secretKey, getPublicKey(secretKey))
+}
+
+export function decodeSecretKey (raw) {
+  if (HEX_SECKEY_REGEX.test(raw)) {
+    return hexToBytes(raw.toLowerCase())
+  }
+  try {
+    return hexToBytes(nsecDecode(raw))
+  } catch (cause) {
+    throw new ValidationError('NOT_A_SECRET_KEY', { cause })
+  }
+}
+
+export function keypairFromSeckey (raw) {
+  const secretKey = decodeSecretKey(raw)
+  return keypairFromSecretKey(secretKey, getPublicKey(secretKey))
+}
+
+export function pubkeyFromNpub (npub) {
+  try {
+    return npubDecode(npub)
+  } catch (cause) {
+    throw new ValidationError('NOT_AN_NPUB', { cause })
+  }
+}
+
+export function nsecFromHex (hex) {
+  return nsecEncode(hex)
+}
+
+export function npubFromPubkey (pubkey) {
+  return npubEncode(pubkey)
+}
+
+function cleanProfileValue (value) {
+  return String(value ?? '').trim()
+}
+
+function profileContentFromEvent (event) {
+  if (!event?.content) return {}
+  try {
+    const parsed = JSON.parse(event.content)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
+  } catch {}
+  return {}
+}
+
+export function profileEventTemplate ({ name = '', picture = '', profileEvent = null } = {}) {
+  const cleanName = cleanProfileValue(name)
+  const cleanPicture = cleanProfileValue(picture)
+  const content = profileContentFromEvent(profileEvent)
+
+  if (cleanName) content.name = cleanName
+  else delete content.name
+  if (cleanPicture) content.picture = cleanPicture
+  else delete content.picture
+
+  const tags = Array.isArray(profileEvent?.tags)
+    ? profileEvent.tags
+      .filter(t => Array.isArray(t) && t[0] !== 'name' && t[0] !== 'picture')
+      .map(t => t.slice())
+    : []
+  if (cleanName) tags.push(['name', cleanName])
+  if (cleanPicture) tags.push(['picture', cleanPicture])
+
+  return {
+    kind: 0,
+    created_at: Math.floor(Date.now() / 1000),
+    tags,
+    content: JSON.stringify(content)
+  }
+}
+
+export function signProfileEvent ({ secretKey, name = '', picture, profileEvent = null }) {
+  return finalizeEvent(profileEventTemplate({ name, picture, profileEvent }), secretKey)
+}
+
+export function relayListTags ({ writeRelays = [], readRelays = [] }) {
+  const write = new Set(writeRelays)
+  const read = new Set(readRelays)
+  const all = new Set([...write, ...read])
+  const tags = []
+  for (const url of all) {
+    const isWrite = write.has(url)
+    const isRead = read.has(url)
+    if (isWrite && isRead) tags.push(['r', url])
+    else if (isWrite) tags.push(['r', url, 'write'])
+    else tags.push(['r', url, 'read'])
+  }
+  return tags
+}
+
+export function signRelayListEvent ({ secretKey, writeRelays = [], readRelays = [] }) {
+  return finalizeEvent({
+    kind: 10002,
+    created_at: Math.floor(Date.now() / 1000),
+    tags: relayListTags({ writeRelays, readRelays }),
+    content: ''
+  }, secretKey)
+}
+
+export function parseProfileEvent (event) {
+  if (!event || event.kind !== 0) return { name: '', picture: '' }
+  let parsed = {}
+  try { parsed = JSON.parse(event.content) } catch { parsed = {} }
+  const fromTag = name => event.tags.find(t => t[0] === name)?.[1]
+  return {
+    name: (fromTag('name') || parsed.name || parsed.display_name || '').trim(),
+    about: (parsed.about || '').trim(),
+    picture: (fromTag('picture') || parsed.picture || '').trim()
+  }
+}

package/key/index.js

@@ -1,114 +1,74 @@
-import { schnorr, secp256k1 } from '@noble/curves/secp256k1.js'
-
-import { bytesToHex, hexToBytes } from '../base16/index.js'
-import { ValidationError } from '../error/index.js'
+import { bytesToBase16 } from '../base16/index.js'
 import { finalizeEvent } from '../event/index.js'
-import { nsecDecode, nsecEncode, npubDecode, npubEncode } from '../nip19/index.js'
-
-const HEX_SECKEY_REGEX = /^[0-9a-f]{64}$/i
-
-export function generateSecretKey () {
-  return schnorr.utils.randomSecretKey()
+import {
+  getReadyEventCryptoBackend,
+  markEventCryptoUnavailable,
+  scheduleEventCryptoInitialization
+} from '../helpers/secp256k1-wasm/backend.js'
+import {
+  decodeSecretKey,
+  generateKeypair as generateKeypairWithJavaScript,
+  generateSecretKey,
+  getPublicKey as getPublicKeyWithJavaScript,
+  keypairFromSecretKey,
+  keypairFromSeckey as keypairFromSeckeyWithJavaScript,
+  npubFromPubkey,
+  nsecFromHex,
+  parseProfileEvent,
+  profileEventTemplate,
+  pubkeyFromNpub,
+  relayListTags,
+  validateSecretKey
+} from './helpers/core.js'
+
+export {
+  generateSecretKey,
+  npubFromPubkey,
+  nsecFromHex,
+  parseProfileEvent,
+  profileEventTemplate,
+  pubkeyFromNpub
 }
 
 export function getPublicKey (secretKey) {
-  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32 || !secp256k1.utils.isValidSecretKey(secretKey)) {
-    throw new ValidationError('INVALID_SECRET_KEY')
+  validateSecretKey(secretKey)
+  scheduleEventCryptoInitialization()
+  const backend = getReadyEventCryptoBackend()
+  if (!backend) return getPublicKeyWithJavaScript(secretKey)
+  try {
+    return bytesToBase16(backend.getPublicKey(secretKey))
+  } catch {
+    markEventCryptoUnavailable()
+    return getPublicKeyWithJavaScript(secretKey)
   }
-  return bytesToHex(schnorr.getPublicKey(secretKey))
 }
 
 export function generateKeypair () {
-  const secretKey = generateSecretKey()
-  const pubkey = getPublicKey(secretKey)
-  return {
-    secretKey,
-    seckey: bytesToHex(secretKey),
-    pubkey,
-    nsec: nsecEncode(bytesToHex(secretKey)),
-    npub: npubEncode(pubkey)
-  }
-}
-
-// Accepts either an `nsec1...` bech32 string or a 64-char hex secret key.
-// Returns both encodings so callers can store the hex form and display the
-// nsec form without re-decoding.
-export function keypairFromSeckey (raw) {
-  let secretKey
-  if (HEX_SECKEY_REGEX.test(raw)) {
-    secretKey = hexToBytes(raw.toLowerCase())
-  } else {
-    try {
-      secretKey = hexToBytes(nsecDecode(raw))
-    } catch (cause) {
-      throw new ValidationError('NOT_A_SECRET_KEY', { cause })
-    }
-  }
-  const pubkey = getPublicKey(secretKey)
-  return {
-    secretKey,
-    seckey: bytesToHex(secretKey),
-    pubkey,
-    nsec: nsecEncode(bytesToHex(secretKey)),
-    npub: npubEncode(pubkey)
-  }
-}
+  scheduleEventCryptoInitialization()
+  const backend = getReadyEventCryptoBackend()
+  if (!backend) return generateKeypairWithJavaScript()
 
-// npub-only: hex pubkeys are not accepted for read-only imports because
-// bech32 includes a checksum that protects against user-typo imports of a
-// pubkey they cannot sign for.
-export function pubkeyFromNpub (npub) {
   try {
-    return npubDecode(npub)
-  } catch (cause) {
-    throw new ValidationError('NOT_AN_NPUB', { cause })
+    const secretKey = generateSecretKey()
+    return keypairFromSecretKey(secretKey, bytesToBase16(backend.getPublicKey(secretKey)))
+  } catch {
+    markEventCryptoUnavailable()
+    return generateKeypairWithJavaScript()
   }
 }
 
-export function nsecFromHex (hex) {
-  return nsecEncode(hex)
-}
-
-export function npubFromPubkey (pubkey) {
-  return npubEncode(pubkey)
-}
-
-function cleanProfileValue (value) {
-  return String(value ?? '').trim()
-}
+export function keypairFromSeckey (raw) {
+  scheduleEventCryptoInitialization()
+  const backend = getReadyEventCryptoBackend()
+  if (!backend) return keypairFromSeckeyWithJavaScript(raw)
 
-function profileContentFromEvent (event) {
-  if (!event?.content) return {}
   try {
-    const parsed = JSON.parse(event.content)
-    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) return parsed
-  } catch {}
-  return {}
-}
-
-export function profileEventTemplate ({ name = '', picture = '', profileEvent = null } = {}) {
-  const cleanName = cleanProfileValue(name)
-  const cleanPicture = cleanProfileValue(picture)
-  const content = profileContentFromEvent(profileEvent)
-
-  if (cleanName) content.name = cleanName
-  else delete content.name
-  if (cleanPicture) content.picture = cleanPicture
-  else delete content.picture
-
-  const tags = Array.isArray(profileEvent?.tags)
-    ? profileEvent.tags
-      .filter(t => Array.isArray(t) && t[0] !== 'name' && t[0] !== 'picture')
-      .map(t => t.slice())
-    : []
-  if (cleanName) tags.push(['name', cleanName])
-  if (cleanPicture) tags.push(['picture', cleanPicture])
-
-  return {
-    kind: 0,
-    created_at: Math.floor(Date.now() / 1000),
-    tags,
-    content: JSON.stringify(content)
+    const secretKey = decodeSecretKey(raw)
+    return keypairFromSecretKey(secretKey, bytesToBase16(backend.getPublicKey(secretKey)))
+  } catch (error) {
+    if (error?.code) throw error
+    markEventCryptoUnavailable()
+    return keypairFromSeckeyWithJavaScript(raw)
   }
 }
 
@@ -116,37 +76,11 @@ export function signProfileEvent ({ secretKey, name = '', picture, profileEvent
   return finalizeEvent(profileEventTemplate({ name, picture, profileEvent }), secretKey)
 }
 
-// Signs a NIP-65 kind:10002 relay-list event. Each URL present in both
-// `writeRelays` and `readRelays` is emitted as a bare `['r', url]` tag;
-// otherwise it gets the explicit `'read'` or `'write'` marker.
 export function signRelayListEvent ({ secretKey, writeRelays = [], readRelays = [] }) {
-  const write = new Set(writeRelays)
-  const read = new Set(readRelays)
-  const all = new Set([...write, ...read])
-  const tags = []
-  for (const url of all) {
-    const isWrite = write.has(url)
-    const isRead = read.has(url)
-    if (isWrite && isRead) tags.push(['r', url])
-    else if (isWrite) tags.push(['r', url, 'write'])
-    else tags.push(['r', url, 'read'])
-  }
   return finalizeEvent({
     kind: 10002,
     created_at: Math.floor(Date.now() / 1000),
-    tags,
+    tags: relayListTags({ writeRelays, readRelays }),
     content: ''
   }, secretKey)
 }
-
-export function parseProfileEvent (event) {
-  if (!event || event.kind !== 0) return { name: '', picture: '' }
-  let parsed = {}
-  try { parsed = JSON.parse(event.content) } catch { parsed = {} }
-  const fromTag = name => event.tags.find(t => t[0] === name)?.[1]
-  return {
-    name: (fromTag('name') || parsed.name || parsed.display_name || '').trim(),
-    about: (parsed.about || '').trim(),
-    picture: (fromTag('picture') || parsed.picture || '').trim()
-  }
-}

package/key/js/index.js

@@ -0,0 +1,13 @@
+export {
+  generateKeypair,
+  generateSecretKey,
+  getPublicKey,
+  keypairFromSeckey,
+  npubFromPubkey,
+  nsecFromHex,
+  parseProfileEvent,
+  profileEventTemplate,
+  pubkeyFromNpub,
+  signProfileEvent,
+  signRelayListEvent
+} from '../helpers/core.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.11.36",
+  "version": "0.12.1",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -46,10 +46,13 @@
     "private-messenger",
     "relay",
     "temporary-storage",
+    "THIRD_PARTY_NOTICES.md",
     "url",
     "web-storage-queue"
   ],
   "scripts": {
+    "benchmark:event": "node --expose-gc benchmark/event-crypto.js",
+    "build:wasm": "node wasm/build.js",
     "test": "node --test --experimental-test-module-mocks 'tests/**/*.test.js'",
     "test:files": "node --test --experimental-test-module-mocks",
     "test:only": "node --test --test-only --experimental-test-module-mocks 'tests/**/*.test.js'"
@@ -67,10 +70,12 @@
     "./ecdh": "./ecdh/index.js",
     "./error": "./error/index.js",
     "./event": "./event/index.js",
+    "./event/js": "./event/js/index.js",
     "./idb": "./idb/index.js",
     "./idb-queue": "./idb-queue/index.js",
     "./irfs": "./irfs/index.js",
     "./key": "./key/index.js",
+    "./key/js": "./key/js/index.js",
     "./kind": "./kind/index.js",
     "./network": "./network/index.js",
     "./nip04": "./nip04/index.js",
@@ -105,6 +110,7 @@
   },
   "devDependencies": {
     "eslint": "^9.39.5",
+    "esbuild": "^0.28.2",
     "fake-indexeddb": "6.2.5",
     "globals": "^17.8.0",
     "neostandard": "^0.13.0"

package/private-channel/helpers/prepared.js

@@ -0,0 +1,12 @@
+import { ValidationError } from '../../error/index.js'
+
+export function normalizePreparedPublications ({ preparedPublication, preparedPublications } = {}) {
+  if (preparedPublication !== undefined) throw new ValidationError('LEGACY_PREPARED_PUBLICATION')
+  if (preparedPublications !== undefined) {
+    if (!Array.isArray(preparedPublications) || preparedPublications.length === 0) {
+      throw new ValidationError('INVALID_PREPARED_PUBLICATIONS')
+    }
+    return preparedPublications
+  }
+  return []
+}