nappup 1.0.5 → 1.0.7

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.5",
+  "version": "1.0.7",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {
-    "test": "node --test 'test/**/*.test.js'"
+    "test": "node --test 'test/**/*.test.js'",
+    "test:only": "node --test --test-only 'test/**/*.test.js'"
   },
   "bin": {
     "nappup": "bin/nappup/index.js"

package/src/helpers/app.js

@@ -0,0 +1,36 @@
+import { bytesToBase62 } from '#helpers/base62.js'
+
+export const NOSTR_APP_ID_MAX_LENGTH = 19
+
+export function isNostrAppDTagSafe (string) {
+  return isSubdomainSafe(string) && string.length <= NOSTR_APP_ID_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)
+}
+
+export function deriveNostrAppDTag (string) {
+  return toSubdomainSafe(string, NOSTR_APP_ID_MAX_LENGTH)
+}
+
+async function toSubdomainSafe (string, maxStringLength) {
+  const byteLength = base62MaxLengthToMaxSourceByteLength(maxStringLength)
+  const bytes = (await toSha1(string)).slice(0, byteLength)
+  return bytesToBase62(bytes, maxStringLength)
+}
+
+async function toSha1 (string) {
+  const bytes = new TextEncoder().encode(string)
+  return new Uint8Array(await crypto.subtle.digest('SHA-1', bytes))
+}
+
+// base62MaxLengthToMaxSourceByteLength(19) === 14 byte length
+function base62MaxLengthToMaxSourceByteLength (maxStringLength) {
+  const log62 = Math.log(62)
+  const log256 = Math.log(256)
+
+  const maxByteLength = (maxStringLength * log62) / log256
+
+  return Math.floor(maxByteLength)
+}

package/src/helpers/base62.js

@@ -0,0 +1,59 @@
+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 = 0) {
+  if (bytes.length === 0) return ''.padStart(padLength, LEADER)
+
+  let num = 0n
+  for (const byte of bytes) {
+    num = (num << 8n) + BigInt(byte)
+  }
+
+  let result = ''
+  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
+
+    result = LEADER + result
+  }
+
+  return result.padStart(padLength, LEADER)
+}
+
+export function base62ToBytes (base62Str) {
+  if (typeof base62Str !== 'string') { throw new Error('base62ToBytes requires a string argument') }
+  if (base62Str.length === 0) return new Uint8Array()
+
+  let leadingZeros = 0
+  for (let i = 0; i < base62Str.length; i++) {
+    if (base62Str[i] !== LEADER) break
+
+    leadingZeros++
+  }
+
+  let num = 0n
+  for (const char of base62Str) {
+    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/byte.js

@@ -0,0 +1,15 @@
+export function bytesToHex (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
+  for (let i = 0; i < arr.length; i++) {
+    const j = i * 2
+    const h = hexString.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
+  }
+  return arr
+}

package/src/helpers/nip19.js

@@ -0,0 +1,90 @@
+import { bytesToHex, hexToBytes } from '#helpers/byte.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['#d'])) { 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)
+    (ref.relays || []).map(url => textEncoder.encode(url)), // type 1
+    [hexToBytes(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 {
+    '#d': textDecoder.decode(tlv[0][0]),
+    pubkey: bytesToHex(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,9 +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 { isNostrAppDTagSafe, deriveNostrAppDTag } from '#helpers/app.js'
 
 export default async function (...args) {
   try {
@@ -12,15 +13,20 @@ export default async function (...args) {
     await nostrRelays.disconnectAll()
   }
 }
-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
   }
 
-  appId ||= fileList[0].webkitRelativePath.split('/')[0]
-    .trim().replace(/[\s-]/g, '').toLowerCase().slice(0, 32)
+  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 {
+    dTag = fileList[0].webkitRelativePath.split('/')[0].trim()
+    if (!isNostrAppDTagSafe(dTag)) dTag = deriveNostrAppDTag(dTag || Math.random().toString(36))
+  }
   let nmmr
   const fileMetadata = []
 
@@ -47,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({
+    '#d': 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 } = {}) {
@@ -110,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
@@ -119,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-signer.js

@@ -5,6 +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'
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 const dotenvPath = process.env.DOTENV_CONFIG_PATH ?? `${__dirname}/../../.env`
@@ -132,22 +133,6 @@ export default class NostrSigner {
   }
 }
 
-function bytesToHex (uint8aBytes) {
-  return Array.from(uint8aBytes).map(b => b.toString(16).padStart(2, '0')).join('')
-}
-
-function hexToBytes (hexString) {
-  const arr = new Uint8Array(hexString.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 b = Number.parseInt(h, 16) // byte, created from string part
-    if (Number.isNaN(b) || b < 0) throw new Error('invalid hex')
-    arr[i] = b
-  }
-  return arr
-}
-
 function generateSecretKey () {
   const randomBytes = crypto.getRandomValues(new Uint8Array(40))
   const B256 = 2n ** 256n // secp256k1 is short weierstrass curve