nappup 1.0.7 → 1.0.8

package/package.json

@@ -6,12 +6,12 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "GPL-3.0-or-later",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
-    "test": "node --test 'test/**/*.test.js'",
-    "test:only": "node --test --test-only 'test/**/*.test.js'"
+    "test": "node --test 'tests/**/*.test.js'",
+    "test:only": "node --test --test-only 'tests/**/*.test.js'"
   },
   "bin": {
     "nappup": "bin/nappup/index.js"

package/src/helpers/app.js

@@ -1,23 +1,26 @@
-import { bytesToBase62 } from '#helpers/base62.js'
+import { bytesToBase36 } from '#helpers/base36.js'
 
-export const NOSTR_APP_ID_MAX_LENGTH = 19
+// 63 - (1<channel> + 5<b36loggeduserpkslug> 50<b36pk>)
+// <b36loggeduserpkslug> pk chars at positions [7][17][27][37][47]
+// to avoid vanity or pow colisions
+export const NOSTR_APP_D_TAG_MAX_LENGTH = 7
 
 export function isNostrAppDTagSafe (string) {
-  return isSubdomainSafe(string) && string.length <= NOSTR_APP_ID_MAX_LENGTH
+  return isSubdomainSafe(string) && string.length <= NOSTR_APP_D_TAG_MAX_LENGTH
 }
 
 function isSubdomainSafe (string) {
-  return /(?:^[A-Za-z0-9]$)|(?:^(?!.*--)[A-Za-z0-9][A-Za-z0-9-]{0,63}[A-Za-z0-9]$)/.test(string)
+  return /(?:^[a-z0-9]$)|(?:^(?!.*--)[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$)/.test(string)
 }
 
 export function deriveNostrAppDTag (string) {
-  return toSubdomainSafe(string, NOSTR_APP_ID_MAX_LENGTH)
+  return toSubdomainSafe(string, NOSTR_APP_D_TAG_MAX_LENGTH)
 }
 
 async function toSubdomainSafe (string, maxStringLength) {
-  const byteLength = base62MaxLengthToMaxSourceByteLength(maxStringLength)
+  const byteLength = baseMaxLengthToMaxSourceByteLength(maxStringLength, 36)
   const bytes = (await toSha1(string)).slice(0, byteLength)
-  return bytesToBase62(bytes, maxStringLength)
+  return bytesToBase36(bytes, maxStringLength)
 }
 
 async function toSha1 (string) {
@@ -25,12 +28,14 @@ async function toSha1 (string) {
   return new Uint8Array(await crypto.subtle.digest('SHA-1', bytes))
 }
 
-// base62MaxLengthToMaxSourceByteLength(19) === 14 byte length
-function base62MaxLengthToMaxSourceByteLength (maxStringLength) {
-  const log62 = Math.log(62)
+// baseMaxLengthToMaxSourceByteLength(19, 62) === 14 byte length
+// baseMaxLengthToMaxSourceByteLength(7, 36) === 4 byte length
+function baseMaxLengthToMaxSourceByteLength (maxStringLength, base) {
+  if (!base) throw new Error('Which base?')
+  const baseLog = Math.log(base)
   const log256 = Math.log(256)
 
-  const maxByteLength = (maxStringLength * log62) / log256
+  const maxByteLength = (maxStringLength * baseLog) / log256
 
   return Math.floor(maxByteLength)
 }

package/src/helpers/{byte.js → base16.js}

@@ -1,12 +1,13 @@
-export function bytesToHex (uint8aBytes) {
+export function bytesToBase16 (uint8aBytes) {
   return Array.from(uint8aBytes).map(b => b.toString(16).padStart(2, '0')).join('')
 }
 
-export function hexToBytes (hexString) {
-  const arr = new Uint8Array(hexString.length / 2) // create result array
+export function base16ToBytes (base16String) {
+  if (base16String.length % 2 !== 0) throw new Error('invalid hex: odd length')
+  const arr = new Uint8Array(base16String.length / 2) // create result array
   for (let i = 0; i < arr.length; i++) {
     const j = i * 2
-    const h = hexString.slice(j, j + 2)
+    const h = base16String.slice(j, j + 2)
     const b = Number.parseInt(h, 16) // byte, created from string part
     if (Number.isNaN(b) || b < 0) throw new Error('invalid hex')
     arr[i] = b

package/src/helpers/base36.js

@@ -0,0 +1,68 @@
+import { base16ToBytes, bytesToBase16 } from '#helpers/base16.js'
+import { base62ToBytes, bytesToBase62 } from '#helpers/base62.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((char, index) => [char, BigInt(index)]))
+
+export function bytesToBase36 (bytes, padLength = 0) {
+  return base16ToBase36(bytesToBase16(bytes), padLength)
+}
+
+export function base16ToBase36 (hex, padLength = 0) {
+  return bigIntToBase36(base16ToBigInt(hex), padLength)
+}
+
+export function base62ToBase36 (base62str, padLength = 0) {
+  return bytesToBase36(base62ToBytes(base62str), padLength)
+}
+
+export function base36ToBytes (base36str) {
+  return base16ToBytes(base36ToBase16(base36str))
+}
+
+export function base36ToBase16 (base36str) {
+  return bigIntToBase16(base36ToBigInt(base36str))
+}
+
+export function base36ToBase62 (base36str, padLength = 0) {
+  return bytesToBase62(base36ToBytes(base36str), padLength)
+}
+
+function base36ToBigInt (base36str) {
+  if (typeof base36str !== 'string') {
+    throw new Error('Input must be a string.')
+  }
+
+  let result = 0n
+  for (const char of base36str) {
+    const value = CHAR_MAP.get(char)
+    if (value === undefined) {
+      throw new Error(`Invalid character in Base36 string: ${char}`)
+    }
+    result = result * BASE + value
+  }
+  return result
+}
+
+function bigIntToBase36 (num, padLength) {
+  if (typeof num !== 'bigint') throw new Error('Input must be a BigInt.')
+  if (num < 0n) throw new Error('Can\'t be signed BigInt')
+
+  return num.toString(36).padStart(padLength, LEADER)
+}
+
+function bigIntToBase16 (num) {
+  if (typeof num !== 'bigint') throw new Error('Input must be a BigInt.')
+  if (num < 0n) throw new Error('Can\'t be signed BigInt')
+
+  let hexString = num.toString(16)
+  if (hexString.length % 2 !== 0) hexString = `0${hexString}`
+  return hexString
+}
+
+function base16ToBigInt (hex) {
+  if (typeof hex !== 'string') throw new Error('Input must be a string.')
+  return BigInt(`0x${hex}`)
+}

package/src/helpers/nip19.js

@@ -1,4 +1,4 @@
-import { bytesToHex, hexToBytes } from '#helpers/byte.js'
+import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
 import { bytesToBase62, base62ToBytes, ALPHABET as base62Alphabet } from '#helpers/base62.js'
 import { isNostrAppDTagSafe } from '#helpers/app.js'
 
@@ -14,14 +14,14 @@ const textEncoder = new TextEncoder()
 const textDecoder = new TextDecoder()
 
 export function appEncode (ref) {
-  if (!isNostrAppDTagSafe(ref['#d'])) { throw new Error('Invalid deduplication tag') }
+  if (!isNostrAppDTagSafe(ref.dTag)) { throw new Error('Invalid deduplication tag') }
   const channelIndex = Object.entries(kindByChannel)
     .findIndex(([k, v]) => ref.channel ? k === ref.channel : v === ref.kind)
   if (channelIndex === -1) throw new Error('Wrong channel')
   const tlv = toTlv([
-    [textEncoder.encode(ref['#d'])], // type 0 (the array index)
+    [textEncoder.encode(ref.dTag)], // type 0 (the array index)
     (ref.relays || []).map(url => textEncoder.encode(url)), // type 1
-    [hexToBytes(ref.pubkey)], // type 2
+    [base16ToBytes(ref.pubkey)], // type 2
     [uintToBytes(channelIndex)] // type 3
   ])
   const base62 = bytesToBase62(tlv)
@@ -39,8 +39,8 @@ export function appDecode (entity) {
 
   const channel = channelEnum[parseInt(tlv[3][0])]
   return {
-    '#d': textDecoder.decode(tlv[0][0]),
-    pubkey: bytesToHex(tlv[2][0]),
+    dTag: textDecoder.decode(tlv[0][0]),
+    pubkey: bytesToBase16(tlv[2][0]),
     kind: kindByChannel[channel],
     channel,
     relays: tlv[1] ? tlv[1].map(url => textDecoder.decode(url)) : []

package/src/index.js

@@ -57,7 +57,7 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, chan
   const bundle = await uploadBundle(dTag, channel, fileMetadata, nostrSigner)
 
   const appEntity = appEncode({
-    '#d': bundle.tags.find(v => v[0] === 'd')[1],
+    dTag: bundle.tags.find(v => v[0] === 'd')[1],
     pubkey: bundle.pubkey,
     relays: [],
     kind: bundle.kind

package/src/services/nostr-relays.js

@@ -43,7 +43,8 @@ export class NostrRelays {
   // Disconnect from a relay.
   async disconnect (url) {
     if (this.#relays.has(url)) {
-      await this.#relays.get(url).close()
+      const relay = this.#relays.get(url)
+      if (relay.ws.readyState < 2) await relay.close().catch(console.log)
       this.#relays.delete(url)
       clearTimeout(this.#relayTimeouts.get(url))
       this.#relayTimeouts.delete(url)

package/src/services/nostr-signer.js

@@ -5,7 +5,7 @@ import * as dotenv from 'dotenv'
 import { getPublicKey, finalizeEvent } from 'nostr-tools/pure'
 import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44'
 import nostrRelays, { seedRelays, freeRelays } from '#services/nostr-relays.js'
-import { bytesToHex, hexToBytes } from '#helpers/byte.js'
+import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 const dotenvPath = process.env.DOTENV_CONFIG_PATH ?? `${__dirname}/../../.env`
@@ -34,17 +34,17 @@ export default class NostrSigner {
   }
 
   static async create (skHex) {
-    if (skHex) return new this(createToken, hexToBytes(skHex))
+    if (skHex) return new this(createToken, base16ToBytes(skHex))
 
     let skBytes
     let isNewSk = false
     if (process.env.NOSTR_SECRET_KEY) {
-      skBytes = hexToBytes(process.env.NOSTR_SECRET_KEY)
+      skBytes = base16ToBytes(process.env.NOSTR_SECRET_KEY)
     } else {
       isNewSk = true
       skHex = generateSecretKey()
       fs.appendFileSync(path.resolve(dotenvPath), `NOSTR_SECRET_KEY=${skHex}\n`)
-      skBytes = hexToBytes(skHex)
+      skBytes = base16ToBytes(skHex)
     }
     const ret = new this(createToken, skBytes)
     if (isNewSk) await ret.#initSk(skHex)
@@ -137,7 +137,7 @@ function generateSecretKey () {
   const randomBytes = crypto.getRandomValues(new Uint8Array(40))
   const B256 = 2n ** 256n // secp256k1 is short weierstrass curve
   const N = B256 - 0x14551231950b75fc4402da1732fc9bebfn // curve (group) order
-  const bytesToNumber = b => BigInt('0x' + (bytesToHex(b) || '0'))
+  const bytesToNumber = b => BigInt('0x' + (bytesToBase16(b) || '0'))
   const mod = (a, b) => { const r = a % b; return r >= 0n ? r : b + r } // mod division
   const num = mod(bytesToNumber(randomBytes), N - 1n) + 1n // takes at least n+8 bytes
   return num.toString(16).padStart(64, '0')