libp2r2p 0.1.0 → 0.3.0

package/README.md

@@ -174,3 +174,16 @@ clearing is asynchronous too: `await messenger.clearChannel(channelPubkey)`.
 Use explicit subpath imports for bundle size. The package root re-exports the
 main messenger API for convenience, but applications that only need one piece
 should import that subpath directly.
+
+## Binary encodings
+
+Base16, Base36, Base62, Base64/Base64URL, and Base93 helpers are available
+through their matching `libp2r2p/<encoding>` subpaths. Base36 exposes both a
+binary-safe variable-width codec and the canonical 32-byte/50-character
+NsiteBase36 representation from NIP-5A. Base62 uses the same case-sensitive
+alphabet as app NIP-19 entities; its default byte mode preserves leading zero
+bytes, while integer mode supports fixed-width identifiers.
+
+In NIP-5A, "no padding" means that no separate padding character such as `=`
+is used. Leading `0` digits are nevertheless required to make every Nsite
+Base36 value exactly 50 characters long.

package/base16/index.js

@@ -5,8 +5,13 @@ export function bytesToBase16 (bytes) {
 }
 
 export function base16ToBytes (base16) {
+  if (typeof base16 !== 'string') throw new TypeError('Base16 value should be a string')
+  if (base16.length % 2 !== 0) throw new Error('Invalid Base16 length')
+  if (!/^[0-9a-f]*$/i.test(base16)) throw new Error('Invalid Base16 character')
   const out = new Uint8Array(base16.length / 2)
-  for (let i = 0; i < out.length; i++) out[i] = parseInt(base16.slice(i * 2, i * 2 + 2), 16)
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(base16.slice(i * 2, i * 2 + 2), 16)
+  }
   return out
 }
 

package/base36/index.js

@@ -0,0 +1,114 @@
+import { base16ToBytes, bytesToBase16 } from '../base16/index.js'
+
+export const BASE36_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+const BASE = BigInt(BASE36_ALPHABET.length)
+const LEADER = BASE36_ALPHABET[0]
+const CHAR_MAP = new Map(
+  [...BASE36_ALPHABET].map((character, index) => [character, BigInt(index)])
+)
+const NSITE_BYTE_LENGTH = 32
+const NSITE_TEXT_LENGTH = 50
+const MAX_NSITE_VALUE = (1n << 256n) - 1n
+
+function bytesToInteger (bytes) {
+  let number = 0n
+  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
+  return number
+}
+
+function integerToBase36 (number) {
+  let result = ''
+  while (number > 0n) {
+    result = BASE36_ALPHABET[Number(number % BASE)] + result
+    number /= BASE
+  }
+  return result || LEADER
+}
+
+function parseBase36Integer (value) {
+  let number = 0n
+  for (const character of value) {
+    const digit = CHAR_MAP.get(character)
+    if (digit === undefined) throw new Error('Invalid Base36 character: ' + character)
+    number = number * BASE + digit
+  }
+  return number
+}
+
+function integerToMinimalBytes (number) {
+  if (number === 0n) return new Uint8Array([0])
+  const bytes = []
+  while (number > 0n) {
+    bytes.unshift(Number(number & 0xffn))
+    number >>= 8n
+  }
+  return Uint8Array.from(bytes)
+}
+
+// A binary-safe Base36 codec. Every leading zero byte is represented by a
+// leading zero character, making arbitrary byte arrays round-trip exactly.
+export function bytesToBase36 (bytes) {
+  if (bytes.length === 0) return ''
+
+  const number = bytesToInteger(bytes)
+  let result = number === 0n ? '' : integerToBase36(number)
+  let leadingZeros = 0
+  while (leadingZeros < bytes.length && bytes[leadingZeros] === 0) leadingZeros++
+  result = LEADER.repeat(leadingZeros) + result
+  return result
+}
+
+export function base36ToBytes (value) {
+  if (typeof value !== 'string') throw new TypeError('Base36 value should be a string')
+  if (value.length === 0) return new Uint8Array()
+
+  let leadingZeros = 0
+  while (value[leadingZeros] === LEADER) leadingZeros++
+  const number = parseBase36Integer(value)
+  const suffix = number === 0n ? new Uint8Array() : integerToMinimalBytes(number)
+  const result = new Uint8Array(leadingZeros + suffix.length)
+  result.set(suffix, leadingZeros)
+  return result
+}
+
+export function base16ToBase36 (value) {
+  return bytesToBase36(base16ToBytes(value))
+}
+
+export function base36ToBase16 (value) {
+  return bytesToBase16(base36ToBytes(value))
+}
+
+// NIP-5A treats a raw 32-byte value as one unsigned integer and represents it
+// as exactly 50 lowercase Base36 digits. Its leading zeros are numeric width,
+// not zero-byte markers as they are in the binary-safe codec above.
+export function bytesToNsiteBase36 (bytes) {
+  if (bytes.length !== NSITE_BYTE_LENGTH) {
+    throw new Error('Nsite Base36 input should be ' + NSITE_BYTE_LENGTH + ' bytes')
+  }
+  return integerToBase36(bytesToInteger(bytes)).padStart(NSITE_TEXT_LENGTH, LEADER)
+}
+
+export function nsiteBase36ToBytes (value) {
+  if (typeof value !== 'string') throw new TypeError('Nsite Base36 value should be a string')
+  if (value.length !== NSITE_TEXT_LENGTH) {
+    throw new Error('Nsite Base36 value should be ' + NSITE_TEXT_LENGTH + ' characters')
+  }
+  if (!/^[0-9a-z]+$/.test(value)) throw new Error('Invalid Nsite Base36 character')
+
+  const number = parseBase36Integer(value)
+  if (number > MAX_NSITE_VALUE) throw new Error('Nsite Base36 value exceeds 32 bytes')
+  const bytes = integerToMinimalBytes(number)
+  const result = new Uint8Array(NSITE_BYTE_LENGTH)
+  if (number !== 0n) result.set(bytes, NSITE_BYTE_LENGTH - bytes.length)
+  return result
+}
+
+export function base16ToNsiteBase36 (value) {
+  return bytesToNsiteBase36(base16ToBytes(value))
+}
+
+export function nsiteBase36ToBase16 (value) {
+  return bytesToBase16(nsiteBase36ToBytes(value))
+}

package/base62/index.js

@@ -0,0 +1,127 @@
+import { base16ToBytes, bytesToBase16 } from '../base16/index.js'
+
+export const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+const BASE = BigInt(BASE62_ALPHABET.length)
+const LEADER = BASE62_ALPHABET[0]
+const CHAR_MAP = new Map(
+  [...BASE62_ALPHABET].map((character, index) => [character, BigInt(index)])
+)
+
+function readOptions (options, allowedKeys) {
+  if (options === undefined) return {}
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new TypeError('Base62 options should be an object')
+  }
+  for (const key of Object.keys(options)) {
+    if (!allowedKeys.includes(key)) throw new Error('Unknown Base62 option: ' + key)
+  }
+  return options
+}
+
+function readMode (mode = 'bytes') {
+  if (mode !== 'bytes' && mode !== 'integer') throw new Error('Invalid Base62 mode: ' + mode)
+  return mode
+}
+
+function readLength (value, name, defaultValue, minimum = 0) {
+  if (value === undefined) return defaultValue
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    const qualifier = minimum === 0 ? 'non-negative' : 'positive'
+    throw new RangeError('Base62 ' + name + ' should be a ' + qualifier + ' safe integer')
+  }
+  return value
+}
+
+function bytesToInteger (bytes) {
+  let number = 0n
+  for (const byte of bytes) number = (number << 8n) + BigInt(byte)
+  return number
+}
+
+function integerToBase62 (number) {
+  let result = ''
+  while (number > 0n) {
+    result = BASE62_ALPHABET[Number(number % BASE)] + result
+    number /= BASE
+  }
+  return result || LEADER
+}
+
+function parseBase62Integer (value) {
+  let number = 0n
+  for (const character of value) {
+    const digit = CHAR_MAP.get(character)
+    if (digit === undefined) throw new Error('Invalid Base62 character: ' + character)
+    number = number * BASE + digit
+  }
+  return number
+}
+
+function integerToMinimalBytes (number) {
+  if (number === 0n) return new Uint8Array([0])
+  const bytes = []
+  while (number > 0n) {
+    bytes.unshift(Number(number & 0xffn))
+    number >>= 8n
+  }
+  return Uint8Array.from(bytes)
+}
+
+// Byte mode preserves every leading zero byte. Integer mode treats the input
+// as an unsigned big-endian value and supports fixed-width textual output.
+export function bytesToBase62 (bytes, options) {
+  const { mode: rawMode, minLength: rawMinLength } = readOptions(options, ['mode', 'minLength'])
+  const mode = readMode(rawMode)
+  if (mode === 'bytes' && rawMinLength !== undefined) {
+    throw new Error('Base62 minLength requires integer mode')
+  }
+  if (mode === 'integer') {
+    if (bytes.length === 0) throw new Error('Base62 integer input should not be empty')
+    const minLength = readLength(rawMinLength, 'minLength', 0)
+    return integerToBase62(bytesToInteger(bytes)).padStart(minLength, LEADER)
+  }
+  if (bytes.length === 0) return ''
+
+  const number = bytesToInteger(bytes)
+  let result = number === 0n ? '' : integerToBase62(number)
+  let leadingZeros = 0
+  while (leadingZeros < bytes.length && bytes[leadingZeros] === 0) leadingZeros++
+  result = LEADER.repeat(leadingZeros) + result
+  return result
+}
+
+export function base62ToBytes (value, options) {
+  if (typeof value !== 'string') throw new TypeError('Base62 value should be a string')
+  const { mode: rawMode, byteLength: rawByteLength } = readOptions(options, ['mode', 'byteLength'])
+  const mode = readMode(rawMode)
+  if (mode === 'bytes' && rawByteLength !== undefined) {
+    throw new Error('Base62 byteLength requires integer mode')
+  }
+  if (mode === 'integer') {
+    if (value.length === 0) throw new Error('Base62 integer value should not be empty')
+    const byteLength = readLength(rawByteLength, 'byteLength', undefined, 1)
+    const bytes = integerToMinimalBytes(parseBase62Integer(value))
+    if (byteLength === undefined) return bytes
+    if (bytes.length > byteLength) throw new Error('Base62 integer exceeds ' + byteLength + ' bytes')
+    const result = new Uint8Array(byteLength)
+    result.set(bytes, byteLength - bytes.length)
+    return result
+  }
+
+  let leadingZeros = 0
+  while (value[leadingZeros] === LEADER) leadingZeros++
+  const number = parseBase62Integer(value)
+  const suffix = number === 0n ? new Uint8Array() : integerToMinimalBytes(number)
+  const result = new Uint8Array(leadingZeros + suffix.length)
+  result.set(suffix, leadingZeros)
+  return result
+}
+
+export function base16ToBase62 (value, options) {
+  return bytesToBase62(base16ToBytes(value), options)
+}
+
+export function base62ToBase16 (value, options) {
+  return bytesToBase16(base62ToBytes(value, options))
+}

package/base64/index.js

@@ -3,6 +3,9 @@
 // base64 is useful for WebAuthn credential IDs and URL/query-string material.
 
 export function bytesToBase64 (bytes) {
+  if (typeof Buffer === 'function' && typeof Buffer.from === 'function') {
+    return Buffer.from(bytes).toString('base64')
+  }
   let s = ''
   for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i])
   return btoa(s)

package/index.js

@@ -1,6 +1,8 @@
 export * from './private-messenger/index.js'
 
 export * as base16 from './base16/index.js'
+export * as base36 from './base36/index.js'
+export * as base62 from './base62/index.js'
 export * as base64 from './base64/index.js'
 export * as contentKey from './content-key/index.js'
 export * as contentKeyEvent from './content-key/event/index.js'
@@ -10,6 +12,7 @@ export * as idb from './idb/index.js'
 export * as idbQueue from './idb-queue/index.js'
 export * as key from './key/index.js'
 export * as network from './network/index.js'
+export * as nip19 from './nip19/index.js'
 export * as nip44v3 from './nip44-v3/index.js'
 export * as nip46 from './nip46/index.js'
 export * as privateChannel from './private-channel/index.js'

package/nip19/index.js

@@ -0,0 +1,260 @@
+import { bech32 } from '@scure/base'
+import { BASE62_ALPHABET, base62ToBytes, bytesToBase62 } from '../base62/index.js'
+
+const MAX_ENTITY_SIZE = 5000
+const MAX_TLV_VALUE_SIZE = 255
+const NOSTR_APP_D_TAG_MAX_LENGTH = 260
+export const NAPP_ENTITY_REGEX = new RegExp(
+  `^\\+{1,3}[${BASE62_ALPHABET}]{48,${MAX_ENTITY_SIZE}}$`
+)
+
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+const fatalTextDecoder = new TextDecoder('utf-8', { fatal: true })
+
+const kindByChannel = {
+  main: 35128,
+  next: 35129,
+  draft: 35130
+}
+const channelByKind = Object.fromEntries(
+  Object.entries(kindByChannel).map(([channel, kind]) => [kind, channel])
+)
+const prefixByChannel = {
+  main: '+',
+  next: '++',
+  draft: '+++'
+}
+const channelByPrefix = Object.fromEntries(
+  Object.entries(prefixByChannel).map(([channel, prefix]) => [prefix, channel])
+)
+
+function bytesToHex (bytes) {
+  let result = ''
+  for (const byte of bytes) result += byte.toString(16).padStart(2, '0')
+  return result
+}
+
+function hexToBytes (hex, fieldName = 'hex value') {
+  if (typeof hex !== 'string' || !/^[0-9a-f]+$/i.test(hex) || hex.length % 2 !== 0) {
+    throw new Error(`Invalid ${fieldName}`)
+  }
+  const result = new Uint8Array(hex.length / 2)
+  for (let index = 0; index < result.length; index++) {
+    result[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)
+  }
+  return result
+}
+
+function fixedHexToBytes (hex, byteLength, fieldName) {
+  const bytes = hexToBytes(hex, fieldName)
+  if (bytes.length !== byteLength) throw new Error(`${fieldName} should be ${byteLength} bytes`)
+  return bytes
+}
+
+function concatBytes (arrays) {
+  const size = arrays.reduce((total, array) => total + array.length, 0)
+  const result = new Uint8Array(size)
+  let offset = 0
+  for (const array of arrays) {
+    result.set(array, offset)
+    offset += array.length
+  }
+  return result
+}
+
+function encodeText (value, fieldName) {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`${fieldName} should be a non-empty string`)
+  }
+  const bytes = textEncoder.encode(value)
+  if (bytes.length > MAX_TLV_VALUE_SIZE) throw new Error(`${fieldName} is too big`)
+  // TextEncoder replaces lone surrogates. Reject them instead of silently changing
+  // the signed/canonical entity value.
+  if (fatalTextDecoder.decode(bytes) !== value) throw new Error(`Invalid ${fieldName} UTF-8`)
+  return bytes
+}
+
+function decodeText (bytes, fieldName) {
+  if (bytes.length === 0 || bytes.length > MAX_TLV_VALUE_SIZE) {
+    throw new Error(`Invalid ${fieldName} length`)
+  }
+  try {
+    return fatalTextDecoder.decode(bytes)
+  } catch {
+    throw new Error(`Invalid ${fieldName} UTF-8`)
+  }
+}
+
+function encodeTlvEntries (entries) {
+  return concatBytes(entries.map(([type, value]) => {
+    if (!Number.isInteger(type) || type < 0 || type > 255) throw new Error('Invalid TLV type')
+    if (!(value instanceof Uint8Array)) throw new TypeError('TLV value should be a Uint8Array')
+    if (value.length > MAX_TLV_VALUE_SIZE) throw new Error('TLV value is too big')
+    const entry = new Uint8Array(value.length + 2)
+    entry[0] = type
+    entry[1] = value.length
+    entry.set(value, 2)
+    return entry
+  }))
+}
+
+function decodeTlvEntries (bytes) {
+  const entries = []
+  let offset = 0
+  while (offset < bytes.length) {
+    if (bytes.length - offset < 2) throw new Error('Truncated TLV header')
+    const type = bytes[offset]
+    const length = bytes[offset + 1]
+    offset += 2
+    if (bytes.length - offset < length) throw new Error(`Truncated TLV value for type ${type}`)
+    entries.push([type, bytes.slice(offset, offset + length)])
+    offset += length
+  }
+  return entries
+}
+
+function onlyValue (values, fieldName) {
+  if (values.length > 1) throw new Error(`Duplicate ${fieldName}`)
+  return values[0]
+}
+
+export function nfileEncode ({ root, relays = [], author, mime, filename }) {
+  if (!Array.isArray(relays)) throw new TypeError('relays should be an array')
+  const entries = [[0, fixedHexToBytes(root, 32, 'MMR root')]]
+  for (const relay of relays) entries.push([1, encodeText(relay, 'relay hint')])
+  if (author !== undefined) entries.push([2, fixedHexToBytes(author, 32, 'author hint')])
+  if (mime !== undefined) entries.push([3, encodeText(mime, 'MIME')])
+  if (filename !== undefined) entries.push([4, encodeText(filename, 'filename')])
+
+  const words = bech32.toWords(encodeTlvEntries(entries))
+  return bech32.encode('nfile', words, MAX_ENTITY_SIZE)
+}
+
+export function nfileDecode (entity) {
+  if (typeof entity !== 'string' || entity !== entity.toLowerCase()) {
+    throw new Error('nfile should use canonical lowercase Bech32')
+  }
+  let decoded
+  try {
+    decoded = bech32.decode(entity, MAX_ENTITY_SIZE)
+  } catch (error) {
+    throw new Error(`Invalid nfile: ${error.message}`)
+  }
+  if (decoded.prefix !== 'nfile') throw new Error('Invalid nfile prefix')
+
+  let bytes
+  try {
+    bytes = new Uint8Array(bech32.fromWords(decoded.words))
+  } catch (error) {
+    throw new Error(`Invalid nfile data: ${error.message}`)
+  }
+
+  const known = new Map([[0, []], [1, []], [2, []], [3, []], [4, []]])
+  for (const [type, value] of decodeTlvEntries(bytes)) known.get(type)?.push(value)
+
+  const rootBytes = onlyValue(known.get(0), 'MMR root')
+  if (!rootBytes) throw new Error('Missing MMR root')
+  if (rootBytes.length !== 32) throw new Error('MMR root should be 32 bytes')
+
+  const authorBytes = onlyValue(known.get(2), 'author hint')
+  if (authorBytes && authorBytes.length !== 32) throw new Error('Author hint should be 32 bytes')
+  const mimeBytes = onlyValue(known.get(3), 'MIME')
+  const filenameBytes = onlyValue(known.get(4), 'filename')
+
+  const result = {
+    root: bytesToHex(rootBytes),
+    relays: known.get(1).map(value => decodeText(value, 'relay hint'))
+  }
+  if (authorBytes) result.author = bytesToHex(authorBytes)
+  if (mimeBytes) result.mime = decodeText(mimeBytes, 'MIME')
+  if (filenameBytes) result.filename = decodeText(filenameBytes, 'filename')
+  return result
+}
+
+function isNostrAppDTagSafe (value) {
+  return typeof value === 'string' && value.length <= NOSTR_APP_D_TAG_MAX_LENGTH
+}
+
+export function appEncode (ref) {
+  if (!isNostrAppDTagSafe(ref.dTag)) throw new Error('Invalid deduplication tag')
+  const channel = ref.channel ? (prefixByChannel[ref.channel] && ref.channel) : channelByKind[ref.kind]
+  if (!channel) throw new Error('Wrong channel')
+
+  // Keep the established app-entity byte ordering exactly for compatibility.
+  const groups = [
+    [textEncoder.encode(ref.dTag)],
+    (ref.relays || []).map(relay => textEncoder.encode(relay)),
+    [fixedHexToBytes(ref.pubkey, 32, 'author pubkey')]
+  ]
+  const entries = []
+  groups
+    .map((values, type) => [type, values])
+    .reverse()
+    .forEach(([type, values]) => {
+      for (const value of values) entries.push([type, value])
+    })
+  const entity = `${prefixByChannel[channel]}${bytesToBase62(encodeTlvEntries(entries))}`
+  if (entity.length > MAX_ENTITY_SIZE) throw new Error('App entity is too big')
+  return entity
+}
+
+export function appDecode (entity) {
+  if (typeof entity !== 'string' || entity.length > MAX_ENTITY_SIZE) throw new Error('Invalid app entity')
+  const prefix = entity.match(/^\+*/)?.[0]
+  const channel = channelByPrefix[prefix]
+  if (!channel) throw new Error('Invalid channel')
+
+  const values = new Map()
+  for (const [type, value] of decodeTlvEntries(base62ToBytes(entity.slice(prefix.length)))) {
+    const list = values.get(type) || []
+    list.push(value)
+    values.set(type, list)
+  }
+  const dTagBytes = values.get(0)?.[0]
+  const pubkeyBytes = values.get(2)?.[0]
+  if (!dTagBytes) throw new Error('Missing deduplication tag')
+  if (!pubkeyBytes) throw new Error('Missing author pubkey')
+  if (pubkeyBytes.length !== 32) throw new Error('Author pubkey should be 32 bytes')
+  const dTag = textDecoder.decode(dTagBytes)
+  if (!isNostrAppDTagSafe(dTag)) throw new Error('Invalid deduplication tag')
+
+  return {
+    dTag,
+    pubkey: bytesToHex(pubkeyBytes),
+    kind: kindByChannel[channel],
+    channel,
+    relays: (values.get(1) || []).map(value => textDecoder.decode(value))
+  }
+}
+
+export function npubEncode (hex) {
+  return bech32.encode('npub', bech32.toWords(fixedHexToBytes(hex, 32, 'pubkey')))
+}
+
+export function npubDecode (entity) {
+  return decodeSimpleEntity(entity, 'npub', 'pubkey')
+}
+
+export function nsecEncode (hex) {
+  return bech32.encode('nsec', bech32.toWords(fixedHexToBytes(hex, 32, 'secret key')))
+}
+
+export function nsecDecode (entity) {
+  return decodeSimpleEntity(entity, 'nsec', 'secret key')
+}
+
+function decodeSimpleEntity (entity, prefix, fieldName) {
+  if (typeof entity !== 'string' || !entity.startsWith(`${prefix}1`)) {
+    throw new Error(`Invalid ${prefix} format`)
+  }
+  try {
+    const decoded = bech32.decode(entity)
+    if (decoded.prefix !== prefix) throw new Error(`Invalid ${prefix} prefix`)
+    const bytes = new Uint8Array(bech32.fromWords(decoded.words))
+    if (bytes.length !== 32) throw new Error(`Invalid ${fieldName} length`)
+    return bytesToHex(bytes)
+  } catch (error) {
+    throw new Error(`Failed to decode ${prefix}: ${error.message}`)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",
@@ -13,6 +13,8 @@
   "sideEffects": false,
   "files": [
     "base16",
+    "base36",
+    "base62",
     "base64",
     "base93",
     "content-key",
@@ -23,6 +25,7 @@
     "index.js",
     "key",
     "network",
+    "nip19",
     "nip44-v3",
     "nip46",
     "private-channel",
@@ -39,6 +42,8 @@
   "exports": {
     ".": "./index.js",
     "./base16": "./base16/index.js",
+    "./base36": "./base36/index.js",
+    "./base62": "./base62/index.js",
     "./base64": "./base64/index.js",
     "./base93": "./base93/index.js",
     "./content-key": "./content-key/index.js",
@@ -49,6 +54,7 @@
     "./idb-queue": "./idb-queue/index.js",
     "./key": "./key/index.js",
     "./network": "./network/index.js",
+    "./nip19": "./nip19/index.js",
     "./nip44-v3": "./nip44-v3/index.js",
     "./nip46": "./nip46/index.js",
     "./private-channel": "./private-channel/index.js",
@@ -63,6 +69,7 @@
     "@noble/ciphers": "2.2.0",
     "@noble/curves": "2.2.0",
     "@noble/hashes": "2.2.0",
+    "@scure/base": "2.0.0",
     "nostr-tools": "2.23.5"
   },
   "devDependencies": {