nappup 1.0.6 → 1.0.8

package/bin/nappup/helpers.js

@@ -8,15 +8,15 @@ import { fileTypeFromFile } from 'file-type'
 export function parseArgs (args) {
   let dir = null
   let sk = null
-  let appId = null
+  let dTag = null
   let channel = null
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '-s' && args[i + 1]) {
       sk = args[i + 1]
       i++ // Skip the next argument as it's part of -k
-    } else if (args[i] === '-i' && args[i + 1]) {
-      appId = args[i + 1]
+    } else if (args[i] === '-d' && args[i + 1]) {
+      dTag = args[i + 1]
       i++
     } else if (args[i] === '--main' && channel === null) {
       channel = 'main'
@@ -32,7 +32,7 @@ export function parseArgs (args) {
   return {
     dir: path.resolve(dir ?? '.'),
     sk,
-    appId,
+    dTag,
     channel: channel || 'main'
   }
 }

package/bin/nappup/index.js

@@ -11,7 +11,7 @@ import toApp from '#index.js'
 const args = parseArgs(process.argv.slice(2))
 await confirmArgs(args)
 
-const { dir, sk, appId, channel } = args
+const { dir, sk, dTag, channel } = args
 const fileList = await toFileList(getFiles(dir), dir)
 
-await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), appId, channel })
+await toApp(fileList, await NostrSigner.create(sk), { log: console.log.bind(console), dTag, channel })

package/package.json

@@ -6,11 +6,12 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "GPL-3.0-or-later",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
-    "test": "node --test '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 isNostrAppIdSafe (string) {
-  return isSubdomainSafe(string) && string.length <= NOSTR_APP_ID_MAX_LENGTH
+export function isNostrAppDTagSafe (string) {
+  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 deriveNostrAppId (string) {
-  return toSubdomainSafe(string, NOSTR_APP_ID_MAX_LENGTH)
+export function deriveNostrAppDTag (string) {
+  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/base62.js

@@ -1,56 +1,59 @@
-import { bytesToHex, hexToBytes } from '#helpers/byte.js'
+export const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+const BASE = BigInt(ALPHABET.length)
+const LEADER = ALPHABET[0]
+const CHAR_MAP = new Map([...ALPHABET].map((char, index) => [char, BigInt(index)]))
 
-export function bytesToBase62 (bytes, padLength) {
-  const hex = bytesToHex(bytes)
-  return hexToBase62(hex, padLength)
-}
-
-export function hexToBase62 (hex, padLength) {
-  return bigIntToBase62(BigInt('0x' + hex), padLength)
-}
+export function bytesToBase62 (bytes, padLength = 0) {
+  if (bytes.length === 0) return ''.padStart(padLength, LEADER)
 
-function bigIntToBase62 (num, padLength = 0) {
-  const alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  const base = BigInt(alphabet.length)
-  if (num === 0n) return alphabet[0].padStart(padLength, alphabet[0])
+  let num = 0n
+  for (const byte of bytes) {
+    num = (num << 8n) + BigInt(byte)
+  }
 
   let result = ''
-  let currentNum = num
+  if (num === 0n) return LEADER.padStart(padLength, LEADER)
+
+  while (num > 0n) {
+    const remainder = num % BASE
+    result = ALPHABET[Number(remainder)] + result
+    num = num / BASE
+  }
+
+  for (const byte of bytes) {
+    if (byte !== 0) break
 
-  while (currentNum > 0n) {
-    const remainder = currentNum % base
-    result = alphabet[Number(remainder)] + result
-    currentNum = currentNum / base
+    result = LEADER + result
   }
-  return result.padStart(padLength, alphabet[0])
+
+  return result.padStart(padLength, LEADER)
 }
 
 export function base62ToBytes (base62Str) {
-  const hexString = base62ToHex(base62Str)
-  return hexToBytes(hexString)
-}
+  if (typeof base62Str !== 'string') { throw new Error('base62ToBytes requires a string argument') }
+  if (base62Str.length === 0) return new Uint8Array()
 
-export function base62ToHex (base62Str, padLength = 64 /* nostr hex key */) {
-  const bigIntValue = base62ToBigInt(base62Str)
-  return bigIntValue.toString(16).padStart(padLength, '0')
-}
+  let leadingZeros = 0
+  for (let i = 0; i < base62Str.length; i++) {
+    if (base62Str[i] !== LEADER) break
 
-function base62ToBigInt (base62Str) {
-  const alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
-  const base = BigInt(alphabet.length)
-  // Create a lookup map for faster character value retrieval
-  const charMap = new Map(
-    [...alphabet].map((char, index) => [char, BigInt(index)])
-  )
+    leadingZeros++
+  }
 
-  let result = 0n
+  let num = 0n
   for (const char of base62Str) {
-    const value = charMap.get(char)
-    if (value === undefined) {
-      throw new Error(`Invalid character in Base62 string: ${char}`)
-    }
-    result = result * base + value
+    const value = CHAR_MAP.get(char)
+    if (value === undefined) { throw new Error(`Invalid character in Base62 string: ${char}`) }
+    num = num * BASE + value
+  }
+
+  const bytes = []
+  while (num > 0n) {
+    bytes.unshift(Number(num & 0xffn))
+    num = num >> 8n
   }
 
+  const result = new Uint8Array(leadingZeros + bytes.length)
+  result.set(bytes, leadingZeros)
   return result
 }

package/src/helpers/nip19.js

@@ -0,0 +1,90 @@
+import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
+import { bytesToBase62, base62ToBytes, ALPHABET as base62Alphabet } from '#helpers/base62.js'
+import { isNostrAppDTagSafe } from '#helpers/app.js'
+
+const MAX_SIZE = 5000
+export const BASE62_ENTITY_REGEX = new RegExp(`^app-[${base62Alphabet}]{,${MAX_SIZE}}$`)
+export const kindByChannel = {
+  main: 37448,
+  next: 37449,
+  draft: 37450
+}
+const channelEnum = Object.keys(kindByChannel)
+const textEncoder = new TextEncoder()
+const textDecoder = new TextDecoder()
+
+export function appEncode (ref) {
+  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.dTag)], // type 0 (the array index)
+    (ref.relays || []).map(url => textEncoder.encode(url)), // type 1
+    [base16ToBytes(ref.pubkey)], // type 2
+    [uintToBytes(channelIndex)] // type 3
+  ])
+  const base62 = bytesToBase62(tlv)
+  return `app-${base62}`
+}
+
+export function appDecode (entity) {
+  const [, base62] = entity.split('-')
+  const tlv = tlvToObj(base62ToBytes(base62))
+  if (!tlv[0]?.[0]) throw new Error('Missing deduplication tag')
+  if (!tlv[2]?.[0]) throw new Error('Missing author pubkey')
+  if (tlv[2][0].length !== 32) throw new Error('Author pubkey should be 32 bytes')
+  if (!tlv[3]?.[0]) throw new Error('Missing channel enum')
+  if (tlv[3][0].length !== 1) throw new Error('Channel enum should be 1 byte')
+
+  const channel = channelEnum[parseInt(tlv[3][0])]
+  return {
+    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)) : []
+  }
+}
+
+// Return shortest uint8Array size (not fixed size)
+function uintToBytes (n, bytes = []) {
+  do { bytes.unshift(n & 255) } while ((n >>= 8) > 0)
+  return new Uint8Array(bytes)
+}
+
+function toTlv (tlvConfig) {
+  const arrays = []
+  tlvConfig
+    .map((v, i) => [i, v])
+    .reverse() // if the first type is 0, entity always starts with the '0' char
+    .forEach(([type, values]) => {
+      // just non-empty values will be included
+      values.forEach(v => {
+        if (v.length > 255) throw new Error('Value is too big')
+        const array = new Uint8Array(v.length + 2)
+        array.set([type], 0) // t
+        array.set([v.length], 1) // l
+        array.set(v, 2) // v
+        arrays.push(array)
+      })
+    })
+  return new Uint8Array(arrays.reduce((r, v) => [...r, ...v]))
+}
+
+// { 0: [t0v0], 1: [t1v0, t1v2], 3: [t3v0] }
+function tlvToObj (tlv) {
+  const ret = {}
+  let rest = tlv
+  let t, l, v
+  while (rest.length > 0) {
+    t = rest[0]
+    l = rest[1]
+    v = rest.slice(2, 2 + l)
+    rest = rest.slice(2 + l)
+    if (v.length < l) throw new Error(`not enough data to read on TLV ${t}`)
+    ret[t] ??= []
+    ret[t].push(v)
+  }
+  return ret
+}

package/src/index.js

@@ -1,10 +1,10 @@
 import NMMR from 'nmmr'
-import { naddrEncode } from 'nostr-tools/nip19'
+import { appEncode } from '#helpers/nip19.js'
 import Base122Encoder from '#services/base122-encoder.js'
 import nostrRelays from '#services/nostr-relays.js'
 import NostrSigner from '#services/nostr-signer.js'
 import { streamToChunks } from '#helpers/stream.js'
-import { isNostrAppIdSafe, deriveNostrAppId } from '#helpers/app.js'
+import { isNostrAppDTagSafe, deriveNostrAppDTag } from '#helpers/app.js'
 
 export default async function (...args) {
   try {
@@ -14,18 +14,18 @@ export default async function (...args) {
   }
 }
 
-export async function toApp (fileList, nostrSigner, { log = () => {}, appId, channel = 'main' } = {}) {
+export async function toApp (fileList, nostrSigner, { log = () => {}, dTag, channel = 'main' } = {}) {
   if (!nostrSigner && typeof window !== 'undefined') nostrSigner = window.nostr
   if (!nostrSigner) throw new Error('No Nostr signer found')
   if (typeof window !== 'undefined' && nostrSigner === window.nostr) {
     nostrSigner.getRelays = NostrSigner.prototype.getRelays
   }
 
-  if (typeof appId === 'string') {
-    if (!isNostrAppIdSafe(appId)) throw new Error('appId should be [A-Za-z0-9] with length ranging from 1 to 19')
+  if (typeof dTag === 'string') {
+    if (!isNostrAppDTagSafe(dTag)) throw new Error('dTag should be [A-Za-z0-9] with length ranging from 1 to 19')
   } else {
-    appId = fileList[0].webkitRelativePath.split('/')[0].trim()
-    if (!isNostrAppIdSafe(appId)) appId = deriveNostrAppId(appId || Math.random().toString(36))
+    dTag = fileList[0].webkitRelativePath.split('/')[0].trim()
+    if (!isNostrAppDTagSafe(dTag)) dTag = deriveNostrAppDTag(dTag || Math.random().toString(36))
   }
   let nmmr
   const fileMetadata = []
@@ -53,16 +53,16 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, appId, cha
     }
   }
 
-  log(`Uploading bundle #${appId}`)
-  const bundle = await uploadBundle(appId, channel, fileMetadata, nostrSigner)
+  log(`Uploading bundle #${dTag}`)
+  const bundle = await uploadBundle(dTag, channel, fileMetadata, nostrSigner)
 
-  const naddr = naddrEncode({
-    identifier: bundle.tags.find(v => v[0] === 'd')[1],
+  const appEntity = appEncode({
+    dTag: bundle.tags.find(v => v[0] === 'd')[1],
     pubkey: bundle.pubkey,
     relays: [],
     kind: bundle.kind
   })
-  log(`Visit at https://44billion.net/${naddr}`)
+  log(`Visit at https://44billion.net/${appEntity}`)
 }
 
 async function uploadBinaryDataChunks (nmmr, signer, { mimeType } = {}) {
@@ -116,7 +116,7 @@ async function getPreviousCtags (dTagValue, currentCtagValue, writeRelays, signe
     })
 }
 
-async function uploadBundle (appId, channel, fileMetadata, signer) {
+async function uploadBundle (dTag, channel, fileMetadata, signer) {
   const kind = {
     main: 37448, // stable
     next: 37449, // insider
@@ -125,7 +125,7 @@ async function uploadBundle (appId, channel, fileMetadata, signer) {
   const appBundle = {
     kind,
     tags: [
-      ['d', appId],
+      ['d', dTag],
       ...fileMetadata.map(v => ['file', v.rootHash, v.filename, v.mimeType])
     ],
     content: '',

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')