nappup 1.0.5 → 1.0.6

package/package.json

@@ -6,7 +6,7 @@
     "url": "git+https://github.com/44billion/nappup.git"
   },
   "license": "GPL-3.0-or-later",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Nostr App Uploader",
   "type": "module",
   "scripts": {

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 isNostrAppIdSafe (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 deriveNostrAppId (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,56 @@
+import { bytesToHex, hexToBytes } from '#helpers/byte.js'
+
+export function bytesToBase62 (bytes, padLength) {
+  const hex = bytesToHex(bytes)
+  return hexToBase62(hex, padLength)
+}
+
+export function hexToBase62 (hex, padLength) {
+  return bigIntToBase62(BigInt('0x' + hex), padLength)
+}
+
+function bigIntToBase62 (num, padLength = 0) {
+  const alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  const base = BigInt(alphabet.length)
+  if (num === 0n) return alphabet[0].padStart(padLength, alphabet[0])
+
+  let result = ''
+  let currentNum = num
+
+  while (currentNum > 0n) {
+    const remainder = currentNum % base
+    result = alphabet[Number(remainder)] + result
+    currentNum = currentNum / base
+  }
+  return result.padStart(padLength, alphabet[0])
+}
+
+export function base62ToBytes (base62Str) {
+  const hexString = base62ToHex(base62Str)
+  return hexToBytes(hexString)
+}
+
+export function base62ToHex (base62Str, padLength = 64 /* nostr hex key */) {
+  const bigIntValue = base62ToBigInt(base62Str)
+  return bigIntValue.toString(16).padStart(padLength, '0')
+}
+
+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)])
+  )
+
+  let result = 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
+  }
+
+  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/index.js

@@ -4,6 +4,7 @@ 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'
 
 export default async function (...args) {
   try {
@@ -12,6 +13,7 @@ export default async function (...args) {
     await nostrRelays.disconnectAll()
   }
 }
+
 export async function toApp (fileList, nostrSigner, { log = () => {}, appId, channel = 'main' } = {}) {
   if (!nostrSigner && typeof window !== 'undefined') nostrSigner = window.nostr
   if (!nostrSigner) throw new Error('No Nostr signer found')
@@ -19,8 +21,12 @@ export async function toApp (fileList, nostrSigner, { log = () => {}, appId, cha
     nostrSigner.getRelays = NostrSigner.prototype.getRelays
   }
 
-  appId ||= fileList[0].webkitRelativePath.split('/')[0]
-    .trim().replace(/[\s-]/g, '').toLowerCase().slice(0, 32)
+  if (typeof appId === 'string') {
+    if (!isNostrAppIdSafe(appId)) throw new Error('appId 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))
+  }
   let nmmr
   const fileMetadata = []
 

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