Archipelago — open-source initial import

aiui/packages/app/src/utils/bech32.ts

@@ -0,0 +1,163 @@
+const CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'
+const CHARSET_MAP: Record<string, number> = {}
+for (let i = 0; i < CHARSET.length; i++) CHARSET_MAP[CHARSET[i]] = i
+
+function polymod(values: number[]): number {
+  const GEN = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
+  let chk = 1
+  for (const v of values) {
+    const b = chk >> 25
+    chk = ((chk & 0x1ffffff) << 5) ^ v
+    for (let i = 0; i < 5; i++) {
+      if ((b >> i) & 1) chk ^= GEN[i]
+    }
+  }
+  return chk
+}
+
+function hrpExpand(hrp: string): number[] {
+  const ret: number[] = []
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) >> 5)
+  ret.push(0)
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) & 31)
+  return ret
+}
+
+function convertBits(data: number[], fromBits: number, toBits: number, pad: boolean): number[] | null {
+  let acc = 0
+  let bits = 0
+  const ret: number[] = []
+  const maxv = (1 << toBits) - 1
+
+  for (const value of data) {
+    if (value < 0 || value >> fromBits) return null
+    acc = (acc << fromBits) | value
+    bits += fromBits
+    while (bits >= toBits) {
+      bits -= toBits
+      ret.push((acc >> bits) & maxv)
+    }
+  }
+
+  if (pad) {
+    if (bits > 0) ret.push((acc << (toBits - bits)) & maxv)
+  } else if (bits >= fromBits || ((acc << (toBits - bits)) & maxv)) {
+    return null
+  }
+
+  return ret
+}
+
+export interface Bech32Decoded {
+  hrp: string
+  data: Uint8Array
+}
+
+export function bech32Decode(str: string): Bech32Decoded | null {
+  const lower = str.toLowerCase()
+  const sepPos = lower.lastIndexOf('1')
+  if (sepPos < 1 || sepPos + 7 > lower.length || lower.length > 90) return null
+
+  const hrp = lower.slice(0, sepPos)
+  const dataChars = lower.slice(sepPos + 1)
+
+  const values: number[] = []
+  for (const c of dataChars) {
+    const v = CHARSET_MAP[c]
+    if (v === undefined) return null
+    values.push(v)
+  }
+
+  if (polymod([...hrpExpand(hrp), ...values]) !== 1) return null
+
+  const data5bit = values.slice(0, -6)
+  const bytes = convertBits(data5bit, 5, 8, false)
+  if (!bytes) return null
+
+  return { hrp, data: new Uint8Array(bytes) }
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('')
+}
+
+export function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2)
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16)
+  }
+  return bytes
+}
+
+function createChecksum(hrp: string, data: number[]): number[] {
+  const values = [...hrpExpand(hrp), ...data, 0, 0, 0, 0, 0, 0]
+  const mod = polymod(values) ^ 1
+  const ret: number[] = []
+  for (let i = 0; i < 6; i++) ret.push((mod >> (5 * (5 - i))) & 31)
+  return ret
+}
+
+export function bech32Encode(hrp: string, data: Uint8Array): string {
+  const fiveBit = convertBits(Array.from(data), 8, 5, true)
+  if (!fiveBit) throw new Error('Failed to convert bits')
+  const checksum = createChecksum(hrp, fiveBit)
+  return hrp + '1' + [...fiveBit, ...checksum].map(d => CHARSET[d]).join('')
+}
+
+/** Encode a hex public key as npub1... */
+export function encodeNpub(hexPubkey: string): string {
+  return bech32Encode('npub', hexToBytes(hexPubkey))
+}
+
+/** Decode an npub1... string to a hex public key */
+export function decodeNpub(npubStr: string): string {
+  const decoded = bech32Decode(npubStr)
+  if (!decoded || decoded.hrp !== 'npub' || decoded.data.length !== 32) {
+    throw new Error('Invalid npub')
+  }
+  return bytesToHex(decoded.data)
+}
+
+export interface NIP19Decoded {
+  type: 'npub' | 'note' | 'nevent' | 'nprofile' | 'unknown'
+  hex: string
+  relays?: string[]
+}
+
+export function decodeNIP19(bech32Str: string): NIP19Decoded | null {
+  const decoded = bech32Decode(bech32Str)
+  if (!decoded) return null
+
+  const { hrp, data } = decoded
+
+  if (hrp === 'npub' && data.length === 32) {
+    return { type: 'npub', hex: bytesToHex(data) }
+  }
+
+  if (hrp === 'note' && data.length === 32) {
+    return { type: 'note', hex: bytesToHex(data) }
+  }
+
+  // TLV decoding for nevent/nprofile
+  if (hrp === 'nevent' || hrp === 'nprofile') {
+    let hex = ''
+    const relays: string[] = []
+    let i = 0
+    while (i < data.length) {
+      const tag = data[i]
+      const len = data[i + 1]
+      if (len === undefined) break
+      const value = data.slice(i + 2, i + 2 + len)
+      if (tag === 0) hex = bytesToHex(value)
+      if (tag === 1) relays.push(new TextDecoder().decode(value))
+      i += 2 + len
+    }
+    return {
+      type: hrp === 'nevent' ? 'nevent' : 'nprofile',
+      hex,
+      relays: relays.length > 0 ? relays : undefined,
+    }
+  }
+
+  return { type: 'unknown', hex: bytesToHex(data) }
+}