libp2r2p 0.10.3 → 0.10.5

package/README.md

@@ -264,9 +264,18 @@ import {
 import { generateSecretKey, getPublicKey } from 'libp2r2p/key'
 import { eventKinds, classifyKind } from 'libp2r2p/kind'
 import * as nip44 from 'libp2r2p/nip44'
-import { assertValidPublicRelayUrl, normalizeRelayUrl } from 'libp2r2p/url'
+import {
+  assertValidPublicBlossomServerUrl,
+  assertValidPublicRelayUrl,
+  normalizeBlossomServerUrl,
+  normalizeRelayUrl
+} from 'libp2r2p/url'
 ```
 
+Blossom server normalization accepts root `http:` origins for local
+development. Public Blossom validation additionally requires `https:` and a
+public host, and rejects credentials, paths, query strings and fragments.
+
 `classifyEvent()` from `libp2r2p/event` combines the exact NIP-01 kind
 ranges with tag-defined behavior. The first `d` tag may add `replaceable` or
 `addressable`, while an `expiration` tag equal to `created_at` adds
@@ -278,6 +287,12 @@ NIP-44 v2 uses the interoperable `nip44-v2` salt by default. A custom UTF-8
 salt of at most 32 bytes may be passed to `getConversationKey()`, but messages
 derived with it are not interoperable with standard NIP-44 implementations.
 
+NIP-46 clients and bunker signers use a 30-second operation timeout by
+default. Set `timeout` in the `Nip46Client`/`BunkerSigner` constructor to
+choose another default, override it for an individual `connect()` or RPC, or
+pass `timeout: null` explicitly when an operation is intentionally allowed to
+wait indefinitely.
+
 Nostr Web Tokens are available from `libp2r2p/nwt`. Creation returns a signed
 kind `27519` event, while transport encoding is kept separate:
 

package/nip46/services/client.js

@@ -129,7 +129,9 @@ export class Nip46Client {
   get pointer () { return { ...this.#pointer, relays: [...this.#pointer.relays] } }
 
   // Connects and immediately asks the remote signer for its preferred relays.
-  async connect ({ requestedPermissions = [], clientMetadata, timeout = null, signal } = {}) {
+  // An omitted timeout inherits the configurable constructor timeout; null
+  // explicitly disables the response deadline.
+  async connect ({ requestedPermissions = [], clientMetadata, timeout, signal } = {}) {
     const permissions = Array.isArray(requestedPermissions)
       ? requestedPermissions.filter(permission => typeof permission === 'string' && permission).join(',')
       : ''

package/nip46/services/transport.js

@@ -59,7 +59,7 @@ export class Nip46Transport {
   #secretKey
   #pubkey
   #relayPool
-  #networkTimeout
+  #operationTimeout
   #timeoutAfterFirstEose
   #onError
   #contexts = new Set()
@@ -80,7 +80,7 @@ export class Nip46Transport {
     this.#secretKey = secretKey
     this.#pubkey = getPublicKey(secretKey)
     this.#relayPool = relayPool
-    this.#networkTimeout = networkTimeout
+    this.#operationTimeout = networkTimeout
     this.#timeoutAfterFirstEose = timeoutAfterFirstEose
     this.#onError = onError
   }
@@ -111,7 +111,7 @@ export class Nip46Transport {
     return context
   }
 
-  async awaitContextReady (context, { timeout = this.#networkTimeout, signal } = {}) {
+  async awaitContextReady (context, { timeout = this.#operationTimeout, signal } = {}) {
     const report = await waitForNip46(context.stream.ready, {
       timeout,
       signal,
@@ -159,11 +159,14 @@ export class Nip46Transport {
     return true
   }
 
-  async sendRequest (peerPubkey, method, params = [], {
-    timeout = null,
-    signal,
-    extension
-  } = {}) {
+  async sendRequest (peerPubkey, method, params = [], options = {}) {
+    const {
+      // Undefined inherits the constructor-wide operation timeout. Passing
+      // null explicitly is the opt-out for RPCs that may wait indefinitely.
+      timeout = this.#operationTimeout,
+      signal,
+      extension
+    } = options
     if (this.#closed) throw new Error('NIP46_CLOSED')
     if (typeof method !== 'string' || !method) throw new ValidationError('NIP46_METHOD_REQUIRED')
     if (!Array.isArray(params) || !params.every(param => typeof param === 'string')) {
@@ -229,7 +232,7 @@ export class Nip46Transport {
     if (!relays.length) throw new Error('NIP46_NO_READY_RELAYS')
     const event = createNip46Event({ secretKey: this.#secretKey, recipientPubkey: peerPubkey, payload })
     const published = await this.#relayPool.sendEvent(event, relays, {
-      timeout: this.#networkTimeout,
+      timeout: this.#operationTimeout,
       timeoutUntilFirstFulfillment: null
     })
     if (!published.success) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",

package/url/index.js

@@ -53,6 +53,30 @@ function removeEmptyQuerySegments (url) {
   url.searchParams.sort()
 }
 
+function publicHostError (url, {
+  invalidHostCode,
+  nonPublicHostCode,
+  nonPublicIpCode
+}) {
+  const hostname = url.hostname.toLowerCase().replace(/\.+$/, '')
+  if (
+    hostname === 'localhost' ||
+    hostname.endsWith('.localhost') ||
+    hostname.endsWith('.local') ||
+    hostname.endsWith('.onion')
+  ) return nonPublicHostCode
+
+  const unwrappedHostname = hostname.replace(/^\[|\]$/g, '')
+  if (isIpv4Address(unwrappedHostname)) {
+    if (!isPublicIpv4Address(unwrappedHostname)) return nonPublicIpCode
+  } else if (unwrappedHostname.includes(':')) {
+    if (!isPublicIpv6Address(unwrappedHostname)) return nonPublicIpCode
+  } else if (!hostname.includes('.')) {
+    return invalidHostCode
+  }
+  return null
+}
+
 export function normalizeRelayUrl (value) {
   if (typeof value !== 'string' || value.trim().length === 0) {
     throw new ValidationError('INVALID_RELAY_URL', { message: 'URL_SHOULD_BE_A_STRING' })
@@ -76,6 +100,36 @@ export function normalizeRelayUrl (value) {
   return url.toString().replace(/^(wss?:\/\/[^/?#]+)\/(?=[?#]|$)/, '$1')
 }
 
+// Canonicalizes the origin used by the root-level Blossom HTTP endpoints.
+export function normalizeBlossomServerUrl (value) {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new ValidationError('INVALID_BLOSSOM_SERVER_URL', { message: 'URL_SHOULD_BE_A_STRING' })
+  }
+  const input = value.trim()
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(input)) {
+    throw new ValidationError('INVALID_BLOSSOM_SERVER_URL', { message: 'ABSOLUTE_URL_REQUIRED' })
+  }
+  let url
+  try {
+    url = new URL(input)
+  } catch (cause) {
+    throw new ValidationError('INVALID_BLOSSOM_SERVER_URL', { cause })
+  }
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    throw new ValidationError('INVALID_BLOSSOM_SERVER_PROTOCOL')
+  }
+  if (url.username || url.password) {
+    throw new ValidationError('BLOSSOM_SERVER_URL_CREDENTIALS_NOT_ALLOWED')
+  }
+  if (!/^\/*$/.test(url.pathname)) {
+    throw new ValidationError('BLOSSOM_SERVER_URL_PATH_NOT_ALLOWED')
+  }
+  if (url.search) throw new ValidationError('BLOSSOM_SERVER_URL_QUERY_NOT_ALLOWED')
+  if (url.hash) throw new ValidationError('BLOSSOM_SERVER_URL_FRAGMENT_NOT_ALLOWED')
+  url.hostname = url.hostname.replace(/\.+$/, '')
+  return url.origin
+}
+
 function publicRelayUrlError (value) {
   if (typeof value !== 'string' || value.trim().length === 0) return 'INVALID_RELAY_URL'
   let input = value.trim()
@@ -97,22 +151,12 @@ function publicRelayUrlError (value) {
   if (url.protocol !== 'wss:') return 'INSECURE_RELAY_URL'
   if (url.username || url.password) return 'RELAY_URL_CREDENTIALS_NOT_ALLOWED'
 
-  const hostname = url.hostname.toLowerCase()
-  if (
-    hostname === 'localhost' ||
-    hostname.endsWith('.localhost') ||
-    hostname.endsWith('.local') ||
-    hostname.endsWith('.onion')
-  ) return 'NON_PUBLIC_RELAY_HOST'
-
-  const unwrappedHostname = hostname.replace(/^\[|\]$/g, '')
-  if (isIpv4Address(unwrappedHostname)) {
-    if (!isPublicIpv4Address(unwrappedHostname)) return 'NON_PUBLIC_RELAY_IP'
-  } else if (unwrappedHostname.includes(':')) {
-    if (!isPublicIpv6Address(unwrappedHostname)) return 'NON_PUBLIC_RELAY_IP'
-  } else if (!hostname.includes('.')) {
-    return 'INVALID_RELAY_HOST'
-  }
+  const hostError = publicHostError(url, {
+    invalidHostCode: 'INVALID_RELAY_HOST',
+    nonPublicHostCode: 'NON_PUBLIC_RELAY_HOST',
+    nonPublicIpCode: 'NON_PUBLIC_RELAY_IP'
+  })
+  if (hostError) return hostError
 
   const lowerValue = normalized.toLowerCase()
   if (lowerValue.includes('npub1') || lowerValue.includes('nprofile1')) return 'RELAY_URL_NOSTR_ENTITY_NOT_ALLOWED'
@@ -129,3 +173,29 @@ export function assertValidPublicRelayUrl (value) {
   if (code) throw new ValidationError(code)
   return value
 }
+
+function publicBlossomServerUrlError (value) {
+  let normalized
+  try {
+    normalized = normalizeBlossomServerUrl(value)
+  } catch (error) {
+    return error instanceof ValidationError ? error.code : 'INVALID_BLOSSOM_SERVER_URL'
+  }
+  const url = new URL(normalized)
+  if (url.protocol !== 'https:') return 'INSECURE_BLOSSOM_SERVER_URL'
+  return publicHostError(url, {
+    invalidHostCode: 'INVALID_BLOSSOM_SERVER_HOST',
+    nonPublicHostCode: 'NON_PUBLIC_BLOSSOM_SERVER_HOST',
+    nonPublicIpCode: 'NON_PUBLIC_BLOSSOM_SERVER_IP'
+  })
+}
+
+export function isValidPublicBlossomServerUrl (value) {
+  return publicBlossomServerUrlError(value) === null
+}
+
+export function assertValidPublicBlossomServerUrl (value) {
+  const code = publicBlossomServerUrlError(value)
+  if (code) throw new ValidationError(code)
+  return value
+}