nappup 1.9.0 → 2.0.0

package/src/services/blossom-upload.js

@@ -134,7 +134,7 @@ async function uploadFileToServer (serverUrl, signer, file, fileHash, mimeType,
  * Different servers run in parallel.
  *
  * Returns { uploadedFiles: [...], failedFiles: [...] }
- * where each uploadedFile has { file, filename, sha256, mimeType }
+ * where each uploadedFile has { file, filename, sha256, mimeType, size }
  * and each failedFile has { file, filename, mimeType, errors }.
  */
 export async function uploadFilesToBlossom ({
@@ -195,7 +195,8 @@ export async function uploadFilesToBlossom ({
         file: info.file,
         filename: info.filename,
         sha256: info.sha256,
-        mimeType: info.mimeType
+        mimeType: info.mimeType,
+        size: info.file.size
       })
     } else {
       failedFiles.push({

package/src/services/bunker-signer.js

@@ -2,7 +2,6 @@ import { generateSecretKey } from 'nostr-tools/pure'
 import { BunkerSigner, parseBunkerInput } from 'nostr-tools/nip46'
 import { getRelays } from '#helpers/signer.js'
 
-const CONNECT_TIMEOUT = 30_000
 const createToken = Symbol('createToken')
 
 export default class NostrBunkerSigner {
@@ -15,18 +14,25 @@ export default class NostrBunkerSigner {
     this.#publicKey = publicKey
   }
 
-  static async create (bunkerUrl) {
+  static async create (bunkerUrl, { connectTimeout = 30_000 } = {}) {
     const bp = await parseBunkerInput(bunkerUrl)
     if (!bp) throw new Error('Invalid bunker URL')
     if (bp.relays.length === 0) throw new Error('Bunker URL must include at least one relay (?relay=wss://...)')
 
     const clientSk = generateSecretKey()
-    const bunker = new BunkerSigner(clientSk, bp)
-
-    await Promise.race([
-      bunker.connect(),
-      new Promise((_, reject) => setTimeout(() => reject(new Error('Bunker connection timed out')), CONNECT_TIMEOUT))
-    ])
+    const bunker = BunkerSigner.fromBunker(clientSk, bp)
+
+    let timeoutHandle
+    try {
+      await Promise.race([
+        bunker.connect(),
+        new Promise((resolve, reject) => {
+          timeoutHandle = setTimeout(() => reject(new Error('Bunker connection timed out')), connectTimeout)
+        })
+      ])
+    } finally {
+      clearTimeout(timeoutHandle)
+    }
 
     const publicKey = await bunker.getPublicKey()
     return new this(createToken, bunker, publicKey)

package/src/services/irfs-upload.js

@@ -1,13 +1,14 @@
 import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
-import Base93Encoder from '#services/base93-encoder.js'
+import NMMR from 'nmmr'
+import { decode as base93Decode, encode as base93Encode } from 'libp2r2p/base93'
 import { stringifyEvent } from '#helpers/event.js'
 
 /**
  * Uploads binary data chunks for a file to Nostr relays using the InterRelay File System (IRFS).
  *
  * Splits file content via NMMR (Nostr Merkle Mountain Range) into chunks,
- * encodes each chunk with Base93, and publishes them as kind 34600 events.
- * Supports resume via created_at cursor alignment with previously stored chunks.
+ * encodes each chunk with Base93, and publishes them as kind 34601 events.
+ * Supports resume by querying the deterministic d tag of each MMR position.
  *
  * @param {object} params
  * @param {object} params.nmmr - NMMR instance with chunks already appended
@@ -16,51 +17,30 @@ import { stringifyEvent } from '#helpers/event.js'
  * @param {number} params.chunkLength - Total number of chunks
  * @param {Function} params.log - Logging function
  * @param {number} [params.pause=0] - Current pause duration in ms (for rate-limit backoff)
- * @param {string} params.mimeType - MIME type of the file
  * @param {boolean} [params.shouldReupload=false] - Whether to force re-upload existing chunks
  * @returns {Promise<{pause: number}>} Updated pause duration
  */
-export async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLength, log, pause = 0, mimeType, shouldReupload = false }) {
-  const pubkey = await signer.getPublicKey()
+export async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLength, log, pause = 0, shouldReupload = false }) {
   const writeRelays = (await signer.getRelays()).write
   const relays = [...new Set([...writeRelays, ...nappRelays].map(r => r.trim().replace(/\/$/, '')))]
-
-  // Find max stored created_at for this file's chunks
   const rootHash = nmmr.getRoot()
-  const allCTags = Array.from({ length: chunkLength }, (_, i) => `${rootHash}:${i}`)
-  let maxStoredCreatedAt = 0
-
-  for (let i = 0; i < allCTags.length; i += 100) {
-    const batch = allCTags.slice(i, i + 100)
-    const storedEvents = (await nostrRelays.getEvents({
-      kinds: [34600],
-      authors: [pubkey],
-      '#c': batch,
-      limit: 1
-    }, relays)).result
-
-    if (storedEvents.length > 0) {
-      const batchMaxCreatedAt = storedEvents.reduce((m, e) => Math.max(m, (e && typeof e.created_at === 'number') ? e.created_at : 0), 0)
-      if (batchMaxCreatedAt > maxStoredCreatedAt) maxStoredCreatedAt = batchMaxCreatedAt
-    }
-  }
-
-  // Set initial created_at based on what's higher, maxStoredCreatedAt or current time
-  let createdAtCursor = (Math.max(maxStoredCreatedAt, Math.floor(Date.now() / 1000)) + chunkLength)
+  const dTags = Array.from({ length: chunkLength }, (_, index) => NMMR.deriveChunkId(rootHash, index))
+  const { eventsByD } = await getPreviousChunks(dTags, relays, signer)
 
   let chunkIndex = 0
   for await (const chunk of nmmr.getChunks()) {
-    const dTag = chunk.x
-    const currentCtag = `${chunk.rootX}:${chunk.index}`
-    const { otherCtags, hasCurrentCtag, foundEvent, missingRelays } = await getPreviousCtags(dTag, currentCtag, relays, signer)
-    if (!shouldReupload && hasCurrentCtag) {
-      // Handling of partial uploads/resumes:
-      // If we are observing an existing chunk, we use its created_at to re-align our cursor
-      // for the next chunks (so next chunk will be this_chunk_time - 1)
-      if (foundEvent) {
-        createdAtCursor = foundEvent.created_at - 1
-      }
-
+    if (chunk.total !== chunkLength || chunk.index !== chunkIndex) {
+      throw new Error('NMMR yielded inconsistent chunk metadata')
+    }
+    const dTag = NMMR.deriveChunkId(rootHash, chunk.index)
+    const storedEvents = eventsByD.get(dTag) ?? []
+    const validEvents = storedEvents.filter(event => isExpectedChunkEvent(event, { rootHash, index: chunk.index, total: chunk.total, dTag }))
+      .sort(compareEventsNewestFirst)
+    const foundEvent = validEvents[0]
+    const coveredRelays = new Set(validEvents.filter(event => event.id === foundEvent?.id).map(event => event.meta?.relay).filter(Boolean))
+    const missingRelays = relays.filter(relay => !coveredRelays.has(relay))
+
+    if (!shouldReupload && foundEvent) {
       if (missingRelays.length === 0) {
         log(`${filename}: Skipping chunk ${++chunkIndex} of ${chunkLength} (already uploaded)`)
         continue
@@ -70,21 +50,18 @@ export async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLen
       continue
     }
 
-    const effectiveCreatedAt = createdAtCursor
-    // The lower chunk index, the higher created_at must be
-    // for relays to serve chunks in the most efficient order
-    createdAtCursor--
+    const now = Math.floor(Date.now() / 1000)
+    const newestStoredCreatedAt = storedEvents.reduce((latest, event) => Math.max(latest, Number.isSafeInteger(event.created_at) ? event.created_at : 0), 0)
+    const effectiveCreatedAt = Math.max(now, newestStoredCreatedAt + 1)
+    if (effectiveCreatedAt > now + 172800) throw new Error('Existing chunk timestamp is too far in the future to replace safely')
 
     const binaryDataChunk = {
-      kind: 34600,
+      kind: 34601,
       tags: [
         ['d', dTag],
-        ...otherCtags,
-        ['c', currentCtag, chunk.length, ...chunk.proof],
-        ...(mimeType ? [['m', mimeType]] : [])
+        ['mmr', String(chunk.index), String(chunk.total), base93Encode(chunk.proof)]
       ],
-      // These chunks already have the expected size of 51000 bytes
-      content: new Base93Encoder().update(chunk.contentBytes).getEncoded(),
+      content: base93Encode(chunk.contentBytes),
       created_at: effectiveCreatedAt
     }
 
@@ -96,6 +73,41 @@ export async function uploadBinaryDataChunks ({ nmmr, signer, filename, chunkLen
   return { pause }
 }
 
+function compareEventsNewestFirst (a, b) {
+  if (a.created_at !== b.created_at) return b.created_at - a.created_at
+  return String(a.id).localeCompare(String(b.id))
+}
+
+export function parseChunkEvent (event) {
+  if (!event || event.kind !== 34601 || !Array.isArray(event.tags)) throw new Error('Wrong chunk event kind or tags')
+  const dTags = event.tags.filter(tag => Array.isArray(tag) && tag[0] === 'd')
+  const mmrTags = event.tags.filter(tag => Array.isArray(tag) && tag[0] === 'mmr')
+  if (dTags.length !== 1 || dTags[0].length !== 2 || !/^[0-9a-f]{64}$/.test(dTags[0][1])) throw new Error('Wrong chunk d tag')
+  if (mmrTags.length !== 1 || mmrTags[0].length !== 4) throw new Error('Wrong chunk mmr tag')
+
+  const [, index, total, encodedProof] = mmrTags[0]
+  const contentBytes = base93Decode(event.content)
+  const proof = base93Decode(encodedProof)
+  const root = NMMR.calculateRoot({ contentBytes, index, total, proof })
+  const numericIndex = Number(index)
+  const numericTotal = Number(total)
+  if (contentBytes.length < 1 || contentBytes.length > 51000 || (numericIndex < numericTotal - 1 && contentBytes.length !== 51000)) {
+    throw new Error('Wrong chunk byte length')
+  }
+  const d = NMMR.deriveChunkId(root, index)
+  if (d !== dTags[0][1]) throw new Error('Chunk d tag mismatch')
+  return { root, index: numericIndex, total: numericTotal, proof, contentBytes, d }
+}
+
+function isExpectedChunkEvent (event, expected) {
+  try {
+    const parsed = parseChunkEvent(event)
+    return parsed.root === expected.rootHash && parsed.index === expected.index && parsed.total === expected.total && parsed.d === expected.dTag
+  } catch (_) {
+    return false
+  }
+}
+
 /**
  * Sends a signed Nostr event to relays with retry logic and rate-limit backoff.
  *
@@ -180,62 +192,25 @@ export async function throttledSendEvent (event, relays, {
   })
 }
 
-/**
- * Checks if a chunk (identified by its d-tag) already exists on relays.
- *
- * Returns info about existing c-tags on the stored event (for deduplication),
- * whether the current c-tag is already present, the found event itself,
- * and which relays are missing the event.
- *
- * @param {string} dTagValue - The d-tag value of the chunk event
- * @param {string} currentCtagValue - The current c-tag value (rootHash:index)
- * @param {string[]} relays - Array of relay URLs to check
- * @param {object} signer - Nostr signer with getPublicKey()
- * @returns {Promise<{otherCtags: Array, hasEvent: boolean, hasCurrentCtag: boolean, foundEvent?: object, missingRelays?: string[]}>}
- */
-export async function getPreviousCtags (dTagValue, currentCtagValue, relays, signer) {
+export async function getPreviousChunks (dTagValues, relays, signer) {
   const targetRelays = [...new Set([...relays, ...nappRelays].map(r => r.trim().replace(/\/$/, '')))]
-  const storedEvents = (await nostrRelays.getEvents({
-    kinds: [34600],
-    authors: [await signer.getPublicKey()],
-    '#d': [dTagValue],
-    limit: 1
-  }, targetRelays)).result
-
-  let hasCurrentCtag = false
-  const hasEvent = storedEvents.length > 0
-  if (!hasEvent) return { otherCtags: [], hasEvent, hasCurrentCtag }
-
-  const cTagValues = { [currentCtagValue]: true }
-  storedEvents.sort((a, b) => b.created_at - a.created_at)
-  const bestEvent = storedEvents[0]
-  const prevTags = bestEvent.tags
-
-  if (!Array.isArray(prevTags)) return { otherCtags: [], hasEvent, hasCurrentCtag }
-
-  hasCurrentCtag = prevTags.some(tag =>
-    Array.isArray(tag) &&
-    tag[0] === 'c' &&
-    tag[1] === currentCtagValue
-  )
-
-  const otherCtags = prevTags
-    .filter(v => {
-      const isCTag =
-        Array.isArray(v) &&
-        v[0] === 'c' &&
-        typeof v[1] === 'string' &&
-        /^[0-9a-f]{64}:\d+$/.test(v[1])
-      if (!isCTag) return false
-
-      const isntDuplicate = !cTagValues[v[1]]
-      cTagValues[v[1]] = true
-      return isCTag && isntDuplicate
-    })
-
-  const matchingEvents = storedEvents.filter(e => e.id === bestEvent.id)
-  const coveredRelays = new Set(matchingEvents.map(e => e.meta?.relay).filter(Boolean))
-  const missingRelays = targetRelays.filter(r => !coveredRelays.has(r))
-
-  return { otherCtags, hasEvent, hasCurrentCtag, foundEvent: bestEvent, missingRelays }
+  const eventsByD = new Map(dTagValues.map(dTag => [dTag, []]))
+  const pubkey = await signer.getPublicKey()
+
+  for (let offset = 0; offset < dTagValues.length; offset += 100) {
+    const batch = dTagValues.slice(offset, offset + 100)
+    const storedEvents = (await nostrRelays.getEvents({
+      kinds: [34601],
+      authors: [pubkey],
+      '#d': batch,
+      limit: batch.length
+    }, targetRelays)).result
+
+    for (const event of storedEvents) {
+      const dTag = event.tags?.find(tag => tag[0] === 'd')?.[1]
+      if (eventsByD.has(dTag)) eventsByD.get(dTag).push(event)
+    }
+  }
+
+  return { eventsByD, targetRelays }
 }

package/src/services/nostr-signer.js

@@ -8,7 +8,7 @@ import nostrRelays, { seedRelays, freeRelays } from '#services/nostr-relays.js'
 import { getRelays } from '#helpers/signer.js'
 import { bytesToBase16, base16ToBytes } from '#helpers/base16.js'
 import { finalizeEvent } from '#helpers/nip01.js'
-import { nsecDecode, nsecEncode } from '#helpers/nip19.js'
+import { nsecDecode, nsecEncode } from 'libp2r2p/nip19'
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 const dotenvPath = process.env.DOTENV_CONFIG_PATH ?? `${__dirname}/../../.env`

package/src/services/site-manifest.js

@@ -0,0 +1,216 @@
+import { NAPP_CATEGORIES } from '#config/napp-categories.js'
+import nostrRelays, { nappRelays } from '#services/nostr-relays.js'
+import { throttledSendEvent } from '#services/irfs-upload.js'
+
+const MANAGED_MANIFEST_TAGS = new Set([
+  'd', 'service', 'path', 'r', 'name', 'summary', 'description', 'self',
+  'c', 'l', 't', 'auto', 'icon', 'key_art', 'screenshot'
+])
+
+export function normalizeManifestPath (value) {
+  if (typeof value !== 'string') throw new TypeError('Manifest path must be a string')
+  const path = value.startsWith('/') ? value.slice(1) : value
+  if (!path || path.includes('\\') || /[\u0000-\u001f\u007f]/.test(path)) {
+    throw new Error(`Unsafe manifest path: ${JSON.stringify(value)}`)
+  }
+  const segments = path.split('/')
+  if (segments.some(segment => !segment || segment === '.' || segment === '..')) {
+    throw new Error(`Unsafe manifest path: ${JSON.stringify(value)}`)
+  }
+  return path
+}
+
+function validRoot (root) {
+  return typeof root === 'string' && /^[0-9a-f]{64}$/.test(root)
+}
+
+function decimalSize (size) {
+  if (!Number.isSafeInteger(size) || size < 0) {
+    throw new Error('Asset size must be a non-negative safe integer')
+  }
+  return String(size)
+}
+
+function addField (fields, type, value) {
+  if (typeof value === 'string' && value) fields.push(`${type} ${value}`)
+}
+
+function buildReferenceTags (uploadService, files, media) {
+  const tags = []
+  if (uploadService === 'blossom') {
+    for (const file of files) {
+      if (!validRoot(file.rootHash)) throw new Error('Invalid Blossom SHA-256 hash')
+      tags.push(['path', normalizeManifestPath(file.filename), file.rootHash])
+    }
+  }
+
+  const groups = new Map()
+  const addToGroup = (asset, fieldType, fieldValue, country) => {
+    if (!asset) return
+    if (!validRoot(asset.rootHash)) throw new Error('Invalid asset root hash')
+    const mimeType = typeof asset.mimeType === 'string' && asset.mimeType
+      ? asset.mimeType
+      : 'application/octet-stream'
+    const size = decimalSize(asset.size)
+    const key = `${asset.rootHash}\u0000${mimeType}\u0000${size}`
+    let group = groups.get(key)
+    if (!group) {
+      group = { root: asset.rootHash, mimeType, size, fields: [] }
+      groups.set(key, group)
+    }
+    addField(group.fields, fieldType, fieldValue)
+    if (fieldType === 'mark' && country) addField(group.fields, 'country', country)
+  }
+
+  if (uploadService === 'irfs') {
+    for (const file of files) addToGroup(file, 'path', normalizeManifestPath(file.filename))
+  }
+  for (const { asset, mark, country } of media) addToGroup(asset, 'mark', mark, country)
+
+  for (const group of groups.values()) {
+    tags.push(['r', group.root, ...group.fields, `m ${group.mimeType}`, `size ${group.size}`])
+  }
+  return tags
+}
+
+function buildMetadataTags ({
+  name, nameLang, isNameAuto, summary, summaryLang, isSummaryAuto,
+  isIconAuto, hasIcon, descriptions, self, countries, categories, hashtags
+}) {
+  const tags = []
+  const trimmedName = typeof name === 'string' ? name.trim() : ''
+  const trimmedSummary = typeof summary === 'string' ? summary.trim() : ''
+
+  if (Array.isArray(countries) && countries.length) {
+    for (const country of countries) {
+      if (typeof country === 'string' && country) tags.push(['c', country])
+    }
+  } else {
+    tags.push(['c', '*'])
+  }
+  if (typeof self === 'string' && self) tags.push(['self', self])
+
+  let categoryCount = 0
+  for (const entry of Array.isArray(categories) ? categories : []) {
+    if (categoryCount >= 3) break
+    if (!Array.isArray(entry)) continue
+    const [category, subcategories] = entry
+    for (const subcategory of Array.isArray(subcategories) ? subcategories : []) {
+      if (categoryCount >= 3) break
+      if (NAPP_CATEGORIES[category]?.includes(subcategory)) {
+        tags.push(['l', `napp.${category}:${subcategory}`])
+        categoryCount++
+      }
+    }
+  }
+
+  for (const entry of (Array.isArray(hashtags) ? hashtags : []).slice(0, 3)) {
+    if (!Array.isArray(entry) || typeof entry[0] !== 'string') continue
+    const value = entry[0].replace(/\s/g, '').toLowerCase()
+    if (!value) continue
+    const tag = ['t', value]
+    if (typeof entry[1] === 'string' && entry[1]) tag.push(entry[1])
+    tags.push(tag)
+  }
+
+  if (trimmedName) {
+    const tag = ['name', trimmedName]
+    if (typeof nameLang === 'string' && nameLang) tag.push(nameLang)
+    tags.push(tag)
+    if (isNameAuto) tags.push(['auto', 'name'])
+  }
+  if (trimmedSummary) {
+    const tag = ['summary', trimmedSummary]
+    if (typeof summaryLang === 'string' && summaryLang) tag.push(summaryLang)
+    tags.push(tag)
+    if (isSummaryAuto) tags.push(['auto', 'summary'])
+  }
+  for (const entry of Array.isArray(descriptions) ? descriptions : []) {
+    if (!Array.isArray(entry) || typeof entry[0] !== 'string' || !entry[0]) continue
+    const tag = ['description', entry[0]]
+    if (typeof entry[1] === 'string' && entry[1]) tag.push(entry[1])
+    tags.push(tag)
+  }
+  if (isIconAuto && hasIcon) tags.push(['auto', 'icon'])
+  return tags
+}
+
+export function buildManifestTags ({
+  dTag, uploadService, fileMetadata = [], icon, keyArt = [], screenshots = [],
+  previousTags = [], ...metadata
+}) {
+  if (uploadService !== 'irfs' && uploadService !== 'blossom') {
+    throw new Error('Unknown upload service')
+  }
+  const media = []
+  if (icon) media.push({ asset: icon, mark: 'icon' })
+  for (const asset of keyArt) media.push({ asset, mark: 'key_art', country: asset.country })
+  for (const asset of screenshots) media.push({ asset, mark: 'screenshot', country: asset.country })
+
+  const unknownTags = (Array.isArray(previousTags) ? previousTags : [])
+    .filter(tag => Array.isArray(tag) && !MANAGED_MANIFEST_TAGS.has(tag[0]))
+    .slice(0, 10)
+    .map(tag => [...tag])
+
+  return [
+    ['d', dTag],
+    ...buildReferenceTags(uploadService, fileMetadata, media),
+    ['service', uploadService],
+    ...buildMetadataTags({ ...metadata, hasIcon: Boolean(icon) }),
+    ...unknownTags
+  ]
+}
+
+function manifestKind (channel) {
+  return {
+    main: 35128,
+    next: 35129,
+    draft: 35130
+  }[channel] ?? 35128
+}
+
+function newestFirst (a, b) {
+  if (b.created_at !== a.created_at) return b.created_at - a.created_at
+  return String(a.id).localeCompare(String(b.id))
+}
+
+export async function uploadSiteManifest ({
+  dTag, channel, fileMetadata, uploadService, signer, pause = 0,
+  shouldReupload = false, log = () => {}, ...metadata
+}) {
+  const kind = manifestKind(channel)
+  const relays = [...new Set([...(await signer.getRelays()).write, ...nappRelays]
+    .map(relay => relay.trim().replace(/\/$/, '')))]
+  const events = (await nostrRelays.getEvents({
+    kinds: [kind],
+    authors: [await signer.getPublicKey()],
+    '#d': [dTag],
+    limit: 1
+  }, relays)).result
+  events.sort(newestFirst)
+  const previous = events[0]
+  const tags = buildManifestTags({
+    dTag, uploadService, fileMetadata, previousTags: previous?.tags, ...metadata
+  })
+
+  if (!shouldReupload && previous && previous.content === '' && JSON.stringify(previous.tags) === JSON.stringify(tags)) {
+    const coveredRelays = new Set(events
+      .filter(event => event.id === previous.id)
+      .map(event => event.meta?.relay)
+      .filter(Boolean))
+    const missingRelays = relays.filter(relay => !coveredRelays.has(relay))
+    if (!missingRelays.length) return previous
+    log(`Re-uploading existing site manifest to ${missingRelays.length} missing relays`)
+    await throttledSendEvent(previous, missingRelays, {
+      pause, trailingPause: true, log, minSuccessfulRelays: 0
+    })
+    return previous
+  }
+
+  const now = Math.floor(Date.now() / 1000)
+  const createdAt = Math.max(now, (previous?.created_at ?? -1) + 1)
+  if (createdAt > now + 172800) throw new Error('Existing manifest timestamp is too far in the future to replace safely')
+  const event = await signer.signEvent({ kind, tags, content: '', created_at: createdAt })
+  await throttledSendEvent(event, relays, { pause, trailingPause: true, log })
+  return event
+}

package/bin/GEMINI.md

@@ -1,6 +0,0 @@
-# bin folder
-
-Place one-off scripts used by package.json's "bin" field.
-
-Each script lives on its own subdirectory and may have its own helpers.js file
-with helper functions.

package/src/helpers/GEMINI.md

@@ -1,12 +0,0 @@
-# helpers folder
-
-- Place helper functions. A helper function is a single-step functionality to be re-used through out the code base.
-- Each functionality is exported as a single function.
-- These functions are not meant to be used within the test folder or sub-folders, except for being unit-tested themselves.
-
-## General Instructions:
-
-- Prefer grouping functions that deal with the same type of variable within the
-same file, preferably named after the type name. E.g.: use `helpers/string.js` for
-exporting helper functions that handle strings, or e.g.: use helpers/stream.js` to
-deal with streams.

package/src/helpers/bech32.js

@@ -1,131 +0,0 @@
-const ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
-
-const ALPHABET_MAP = {}
-for (let z = 0; z < ALPHABET.length; z++) {
-  const x = ALPHABET.charAt(z)
-  ALPHABET_MAP[x] = z
-}
-
-function polymod (values) {
-  const GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
-  let chk = 1
-  for (let p = 0; p < values.length; ++p) {
-    const top = chk >> 25
-    chk = (chk & 0x1ffffff) << 5 ^ values[p]
-    for (let i = 0; i < 5; ++i) {
-      if ((top >> i) & 1) {
-        chk ^= GEN[i]
-      }
-    }
-  }
-  return chk
-}
-
-function hrpExpand (hrp) {
-  const ret = []
-  for (let p = 0; p < hrp.length; ++p) {
-    ret.push(hrp.charCodeAt(p) >> 5)
-  }
-  ret.push(0)
-  for (let p = 0; p < hrp.length; ++p) {
-    ret.push(hrp.charCodeAt(p) & 31)
-  }
-  return ret
-}
-
-function verifyChecksum (hrp, data) {
-  return polymod(hrpExpand(hrp).concat(data)) === 1
-}
-
-function createChecksum (hrp, data) {
-  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0])
-  const mod = polymod(values) ^ 1
-  const ret = []
-  for (let p = 0; p < 6; ++p) {
-    ret.push((mod >> 5 * (5 - p)) & 31)
-  }
-  return ret
-}
-
-export function encode (hrp, data) {
-  const combined = data.concat(createChecksum(hrp, data))
-  let ret = hrp + '1'
-  for (let p = 0; p < combined.length; ++p) {
-    ret += ALPHABET.charAt(combined[p])
-  }
-  return ret
-}
-
-export function decode (bechString, limit = 90) {
-  let p
-  let hasLower = false
-  let hasUpper = false
-  for (p = 0; p < bechString.length; ++p) {
-    if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
-      return null
-    }
-    if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
-      hasLower = true
-    }
-    if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
-      hasUpper = true
-    }
-  }
-  if (hasLower && hasUpper) {
-    return null
-  }
-  bechString = bechString.toLowerCase()
-  const pos = bechString.lastIndexOf('1')
-  if (pos < 1 || pos + 7 > bechString.length || bechString.length > limit) {
-    return null
-  }
-  const hrp = bechString.substring(0, pos)
-  const data = []
-  for (p = pos + 1; p < bechString.length; ++p) {
-    const d = ALPHABET_MAP[bechString.charAt(p)]
-    if (d === undefined) {
-      return null
-    }
-    data.push(d)
-  }
-  if (!verifyChecksum(hrp, data)) {
-    return null
-  }
-  return { hrp, data: data.slice(0, data.length - 6) }
-}
-
-export function toWords (data) {
-  let value = 0
-  let bits = 0
-  const maxV = 31
-  const result = []
-  for (let i = 0; i < data.length; ++i) {
-    value = (value << 8) | data[i]
-    bits += 8
-    while (bits >= 5) {
-      bits -= 5
-      result.push((value >> bits) & maxV)
-    }
-  }
-  if (bits > 0) {
-    result.push((value << (5 - bits)) & maxV)
-  }
-  return result
-}
-
-export function fromWords (data) {
-  let value = 0
-  let bits = 0
-  const maxV = 255
-  const result = []
-  for (let i = 0; i < data.length; ++i) {
-    const element = data[i]
-    value = (value << 5) | element
-    bits += 5
-    while (bits >= 8) {
-      bits -= 8
-      result.push((value >> bits) & maxV)
-    }
-  }
-  return result
-}