126 lines
3.1 KiB
TypeScript
126 lines
3.1 KiB
TypeScript
import * as secp256k1 from '@noble/secp256k1'
|
|
import {bech32} from 'bech32'
|
|
|
|
import {utf8Decoder, utf8Encoder} from './utils'
|
|
|
|
export type ProfilePointer = {
|
|
pubkey: string // hex
|
|
relays?: string[]
|
|
}
|
|
|
|
export type EventPointer = {
|
|
id: string // hex
|
|
relays?: string[]
|
|
}
|
|
|
|
export function decode(nip19: string): {
|
|
type: string
|
|
data: ProfilePointer | EventPointer | string
|
|
} {
|
|
let {prefix, words} = bech32.decode(nip19, 1000)
|
|
let data = new Uint8Array(bech32.fromWords(words))
|
|
|
|
if (prefix === 'nprofile') {
|
|
let tlv = parseTLV(data)
|
|
if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nprofile')
|
|
if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
|
|
|
|
return {
|
|
type: 'nprofile',
|
|
data: {
|
|
pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
|
|
relays: tlv[1].map(d => utf8Decoder.decode(d))
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prefix === 'nevent') {
|
|
let tlv = parseTLV(data)
|
|
if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for nevent')
|
|
if (tlv[0][0].length !== 32) throw new Error('TLV 0 should be 32 bytes')
|
|
|
|
return {
|
|
type: 'nevent',
|
|
data: {
|
|
id: secp256k1.utils.bytesToHex(tlv[0][0]),
|
|
relays: tlv[1].map(d => utf8Decoder.decode(d))
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prefix === 'nsec' || prefix === 'npub' || prefix === 'note') {
|
|
return {type: prefix, data: secp256k1.utils.bytesToHex(data)}
|
|
}
|
|
|
|
throw new Error(`unknown prefix ${prefix}`)
|
|
}
|
|
|
|
type TLV = {[t: number]: Uint8Array[]}
|
|
|
|
function parseTLV(data: Uint8Array): TLV {
|
|
let result: TLV = {}
|
|
let rest = data
|
|
while (rest.length > 0) {
|
|
let t = rest[0]
|
|
let l = rest[1]
|
|
let v = rest.slice(2, 2 + l)
|
|
rest = rest.slice(2 + l)
|
|
if (v.length < l) continue
|
|
result[t] = result[t] || []
|
|
result[t].push(v)
|
|
}
|
|
return result
|
|
}
|
|
|
|
export function nsecEncode(hex: string): string {
|
|
return encodeBytes('nsec', hex)
|
|
}
|
|
|
|
export function npubEncode(hex: string): string {
|
|
return encodeBytes('npub', hex)
|
|
}
|
|
|
|
export function noteEncode(hex: string): string {
|
|
return encodeBytes('note', hex)
|
|
}
|
|
|
|
function encodeBytes(prefix: string, hex: string): string {
|
|
let data = secp256k1.utils.hexToBytes(hex)
|
|
let words = bech32.toWords(data)
|
|
return bech32.encode(prefix, words, 1000)
|
|
}
|
|
|
|
export function nprofileEncode(profile: ProfilePointer): string {
|
|
let data = encodeTLV({
|
|
0: [secp256k1.utils.hexToBytes(profile.pubkey)],
|
|
1: (profile.relays || []).map(url => utf8Encoder.encode(url))
|
|
})
|
|
let words = bech32.toWords(data)
|
|
return bech32.encode('nprofile', words, 1000)
|
|
}
|
|
|
|
export function neventEncode(event: EventPointer): string {
|
|
let data = encodeTLV({
|
|
0: [secp256k1.utils.hexToBytes(event.id)],
|
|
1: (event.relays || []).map(url => utf8Encoder.encode(url))
|
|
})
|
|
let words = bech32.toWords(data)
|
|
return bech32.encode('nevent', words, 1000)
|
|
}
|
|
|
|
function encodeTLV(tlv: TLV): Uint8Array {
|
|
let entries: Uint8Array[] = []
|
|
|
|
Object.entries(tlv).forEach(([t, vs]) => {
|
|
vs.forEach(v => {
|
|
let entry = new Uint8Array(v.length + 2)
|
|
entry.set([parseInt(t)], 0)
|
|
entry.set([v.length], 1)
|
|
entry.set(v, 2)
|
|
entries.push(entry)
|
|
})
|
|
})
|
|
|
|
return secp256k1.utils.concatBytes(...entries)
|
|
}
|