libp2r2p 0.10.13 → 0.10.15

package/README.md

@@ -320,6 +320,14 @@ 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-44 v3 separates binary (`encryptBytes`/`decryptBytes`), UTF-8 text
+(`encrypt`/`decrypt`), and standard-Base64 plaintext
+(`encryptBase64`/`decryptBase64`) interfaces.
+The suffix describes plaintext; ciphertext is always
+standard Base64. NIP-46 uses the Base64 helpers, while browser NIP-07 APIs use
+`ArrayBuffer` plaintext; see [the interface guide](nip44-v3/README.md) before
+adapting a signer.
+
 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
@@ -370,6 +378,29 @@ plus NIP-05 in its standard, root and custom compact spellings.
 reads the file/media metadata carried in a URL fragment
 (`#m=image/png&dim=640x480&...`).
 
+`compactWhitespace(text, options?)` is also exported from `libp2r2p/nip27` as an
+opt-in display helper. It removes carriage returns, collapses spaces and
+tabs, removes spaces around line breaks, limits consecutive line breaks to
+two, keeps the first eight line breaks (replacing subsequent runs with a
+space), and trims the result. Empty strings are accepted; non-string inputs
+throw `ValidationError` with code `INVALID_WHITESPACE_TEXT`. It is not
+applied automatically by `extractMedia()`.
+
+The option `maxLineBreaks` (default `8`) sets the total limit and accepts a
+non-negative safe integer. Setting it to `0` replaces all line-break runs
+with spaces. `consecutiveLineBreakThreshold` (default `3`) sets the minimum
+run length that collapses to **two** line breaks; shorter runs are preserved.
+It accepts safe integers of at least `3`. Either option accepts `Infinity`
+to disable its rule. Runs are collapsed before applying the total limit,
+and trimming happens last. Invalid options throw `ValidationError` with
+code `INVALID_WHITESPACE_OPTIONS`.
+
+```js
+import { compactWhitespace } from 'libp2r2p/nip27'
+
+compactWhitespace(text, { maxLineBreaks: 12, consecutiveLineBreakThreshold: 5 })
+```
+
 User references (`npub`, `nprofile`, hex pubkeys and every NIP-05 spelling)
 are handled by `libp2r2p/nip27`: `decodeUserReference()` returns the decoded
 form with its canonical compact spelling, `encodeUserReference()` returns

package/kind/index.js

@@ -7,6 +7,7 @@ export const DELETION = 5
 export const REPOST = 6
 export const REACTION = 7
 export const BADGE_AWARD = 8
+export const CHAT_MESSAGE = 9
 export const SEAL = 13
 export const PRIVATE_DIRECT_MESSAGE = 14
 export const GENERIC_REPOST = 16
@@ -146,6 +147,7 @@ export const eventKinds = /* @__PURE__ */ Object.freeze({
   REPOST,
   REACTION,
   BADGE_AWARD,
+  CHAT_MESSAGE,
   SEAL,
   PRIVATE_DIRECT_MESSAGE,
   GENERIC_REPOST,

package/nip27/helpers/compact-whitespace.js

@@ -0,0 +1,33 @@
+import { ValidationError } from '../../error/index.js'
+
+// Compacts display text, defaulting to collapsing runs of three or more line
+// breaks to two and keeping eight overall. extractMedia preserves input.
+export function compactWhitespace (text, options = {}) {
+  if (typeof text !== 'string') {
+    throw new ValidationError('INVALID_WHITESPACE_TEXT', { message: 'TEXT_SHOULD_BE_A_STRING' })
+  }
+
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new ValidationError('INVALID_WHITESPACE_OPTIONS', { message: 'OPTIONS_SHOULD_BE_AN_OBJECT' })
+  }
+  const { maxLineBreaks = 8, consecutiveLineBreakThreshold = 3 } = options
+  if (maxLineBreaks !== Infinity && (!Number.isSafeInteger(maxLineBreaks) || maxLineBreaks < 0)) {
+    throw new ValidationError('INVALID_WHITESPACE_OPTIONS', { message: 'MAX_LINE_BREAKS_SHOULD_BE_A_NON_NEGATIVE_SAFE_INTEGER_OR_INFINITY' })
+  }
+  if (consecutiveLineBreakThreshold !== Infinity && (!Number.isSafeInteger(consecutiveLineBreakThreshold) || consecutiveLineBreakThreshold < 3)) {
+    throw new ValidationError('INVALID_WHITESPACE_OPTIONS', { message: 'CONSECUTIVE_LINE_BREAK_THRESHOLD_SHOULD_BE_A_SAFE_INTEGER_AT_LEAST_THREE_OR_INFINITY' })
+  }
+
+  let remainingLineBreaks = maxLineBreaks
+  return text
+    .replace(/\r/g, '')
+    .replace(/[\t ]+/g, ' ')
+    .replace(/ ?\n ?/g, '\n')
+    .replace(/\n+/g, lineBreaks => {
+      const consecutive = lineBreaks.length >= consecutiveLineBreakThreshold ? 2 : lineBreaks.length
+      const kept = Math.min(remainingLineBreaks, consecutive)
+      remainingLineBreaks -= kept
+      return lineBreaks.slice(0, kept) + (kept < consecutive ? ' ' : '')
+    })
+    .trim()
+}

package/nip27/index.js

@@ -14,6 +14,7 @@ import {
 } from './helpers/user-reference.js'
 
 export { decodeUserReference, encodeUserReference, tryDecodeUserReference }
+export { compactWhitespace } from './helpers/compact-whitespace.js'
 
 const BECH32_BODY = '[ac-hj-np-z02-9]'
 const BOUNDARY_PREFIX = /(?<=^|[\s"«„「¡¿:{([])/.source

package/nip44-v3/README.md

@@ -0,0 +1,32 @@
+# NIP-44 v3 interfaces
+
+These public functions separate bytes, UTF-8 text and Base64 convenience.
+Suffixes describe the plaintext input/output format; ciphertexts are standard
+Base64 strings throughout.
+
+| Functions | Plaintext input/output | Scope |
+| --- | --- | --- |
+| `encryptBytes` / `decryptBytes` | `Uint8Array` | UTF-8 bytes (`Uint8Array`) |
+| `encryptWithConversationKeyBytes` / `decryptWithConversationKeyBytes` | `Uint8Array` | UTF-8 bytes (`Uint8Array`) |
+| `encrypt` / `decrypt` | UTF-8 text (`string`) | UTF-8 text (`string`) |
+| `encryptWithConversationKey` / `decryptWithConversationKey` | UTF-8 text (`string`) | UTF-8 text (`string`) |
+| `encryptBase64` / `decryptBase64` | Standard Base64 (`string`) | UTF-8 text (`string`) |
+
+The Base64 helpers decode plaintext before encryption and encode decrypted
+bytes before returning them. Base64URL is not this
+format, and arbitrary bytes must not pass through a UTF-8 text helper.
+
+The [NIP-07 extension](https://github.com/nostr-land/nip44v3/blob/master/extensions/nip07.md)
+defines `window.nostr.nip44v3.encrypt` with an `ArrayBuffer` plaintext and
+`decrypt` with an `ArrayBuffer` result. Browser signer bridges should adapt
+that boundary to their binary implementation or to the Base64
+[NIP-46 transport](https://github.com/nostr-land/nip44v3/blob/master/extensions/nip46.md).
+The library's text convenience functions are not implementations of that
+browser interface. Do not guess whether a string is literal text or Base64.
+
+The [implementation guide](https://github.com/nostr-land/nip44v3/blob/master/implementing.md)
+requires binary support and explicit expected context. Callers choose kind and
+scope from their protocol/event; decrypt verifies them. The
+[NIP-17 extension](https://github.com/nostr-land/nip44v3/blob/master/extensions/nip17.md)
+specifies kind 1059 for gift wraps and 13 for seals, each with empty scope;
+these are protocol choices, not automatic defaults for other event types.

package/nip44-v3/index.js

@@ -113,6 +113,8 @@ export function encryptWithConversationKeyBytes (conversationKey, kind, scope, p
   return bytesToBase64(concatBytes(new Uint8Array([VERSION]), nonce, mac, stuffing))
 }
 
+// seckey/expectedScope: Uint8Array, pubkey: hex, ciphertext: standard Base64 string.
+// Verifies the expected kind/scope and returns plaintext bytes as Uint8Array.
 export function decryptBytes (seckey, pubkey, expectedKind, expectedScope, ciphertext) {
   return decryptWithConversationKeyBytes(deriveSharedConversationKey(seckey, pubkey), expectedKind, expectedScope, ciphertext)
 }
@@ -162,8 +164,7 @@ export function normalizeKind (kind) {
   return n
 }
 
-// String-oriented helpers for app-facing methods. Plaintext travels as
-// base64 on the NIP-07/46 wire so callers can encrypt arbitrary bytes.
+// UTF-8 convenience helpers. Binary callers use encryptBytes/decryptBytes.
 export function encrypt (seckey, pubkey, kind, scope, plaintext) {
   return encryptBytes(seckey, pubkey, normalizeKind(kind), utf8ToBytes(scope || ''), utf8ToBytes(plaintext))
 }
@@ -180,11 +181,14 @@ export function decryptWithConversationKey (conversationKey, kind, scope, cipher
   return textDecoder.decode(decryptWithConversationKeyBytes(conversationKey, normalizeKind(kind), utf8ToBytes(scope || ''), ciphertext))
 }
 
-export function nip07Encrypt (seckey, pubkey, kind, scope, plaintextB64) {
+// Base64 convenience helpers: the suffix describes plaintext input/output.
+// Ciphertext is always standard Base64. NIP-46 uses this plaintext format;
+// NIP-07 instead exposes ArrayBuffer plaintext at the browser API boundary.
+export function encryptBase64 (seckey, pubkey, kind, scope, plaintextB64) {
   return encryptBytes(seckey, pubkey, normalizeKind(kind), utf8ToBytes(scope || ''), base64ToBytes(plaintextB64))
 }
 
-export function nip07Decrypt (seckey, pubkey, kind, scope, ciphertext) {
+export function decryptBase64 (seckey, pubkey, kind, scope, ciphertext) {
   return bytesToBase64(decryptBytes(seckey, pubkey, normalizeKind(kind), utf8ToBytes(scope || ''), ciphertext))
 }
 

package/package.json

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