bump to v1.5.0

README.md

@@ -4,6 +4,13 @@ Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
 Only depends on _@scure_ and _@noble_ packages.
 
+## Installation
+
+```bash
+ npm install nostr-tools # or yarn add nostr-tools
+```
+
+
 ## Usage
 
 ### Generating a private key and a public key
@@ -53,8 +60,6 @@ import {
 } from 'nostr-tools'
 
 const relay = relayInit('wss://relay.example.com')
-await relay.connect()
-
 relay.on('connect', () => {
   console.log(`connected to ${relay.url}`)
 })
@@ -62,6 +67,8 @@ relay.on('error', () => {
   console.log(`failed to connect to ${relay.url}`)
 })
 
+await relay.connect()
+
 // let's query for an event that exists
 let sub = relay.sub([
   {

event.ts

@@ -2,6 +2,7 @@ import * as secp256k1 from '@noble/secp256k1'
 import {sha256} from '@noble/hashes/sha256'
 
 import {utf8Encoder} from './utils'
+import {getPublicKey} from './keys'
 
 /* eslint-disable no-unused-vars */
 export enum Kind {
@@ -32,8 +33,11 @@ export type EventTemplate = {
   created_at: number
 }
 
-export type Event = EventTemplate & {
+export type UnsignedEvent = EventTemplate & {
   pubkey: string
+}
+
+export type Event = UnsignedEvent & {
   id: string
   sig: string
 }
@@ -47,7 +51,15 @@ export function getBlankEvent(): EventTemplate {
   }
 }
 
-export function serializeEvent(evt: Event): string {
+export function finishEvent(t: EventTemplate, privateKey: string): Event {
+  let event = t as Event
+  event.pubkey = getPublicKey(privateKey)
+  event.id = getEventHash(event)
+  event.sig = signEvent(event, privateKey)
+  return event
+}
+
+export function serializeEvent(evt: UnsignedEvent): string {
   if (!validateEvent(evt))
     throw new Error("can't serialize event with wrong or missing properties")
 
@@ -61,12 +73,12 @@ export function serializeEvent(evt: Event): string {
   ])
 }
 
-export function getEventHash(event: Event): string {
+export function getEventHash(event: UnsignedEvent): string {
   let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
   return secp256k1.utils.bytesToHex(eventHash)
 }
 
-export function validateEvent(event: Event): boolean {
+export function validateEvent(event: UnsignedEvent): boolean {
   if (typeof event !== 'object') return false
   if (typeof event.content !== 'string') return false
   if (typeof event.created_at !== 'number') return false
@@ -93,7 +105,7 @@ export function verifySignature(event: Event & {sig: string}): boolean {
   )
 }
 
-export function signEvent(event: Event, key: string): string {
+export function signEvent(event: UnsignedEvent, key: string): string {
   return secp256k1.utils.bytesToHex(
     secp256k1.schnorr.signSync(getEventHash(event), key)
   )

nip19.test.js

@@ -34,3 +34,25 @@ test('encode and decode nprofile', () => {
   expect(data.relays).toContain(relays[0])
   expect(data.relays).toContain(relays[1])
 })
+
+test('encode and decode naddr', () => {
+  let pk = getPublicKey(generatePrivateKey())
+  let relays = [
+    'wss://relay.nostr.example.mydomain.example.com',
+    'wss://nostr.banana.com'
+  ]
+  let naddr = nip19.naddrEncode({
+    pubkey: pk,
+    relays,
+    kind: 30023,
+    identifier: 'banana'
+  })
+  expect(naddr).toMatch(/naddr1\w+/)
+  let {type, data} = nip19.decode(naddr)
+  expect(type).toEqual('naddr')
+  expect(data.pubkey).toEqual(pk)
+  expect(data.relays).toContain(relays[0])
+  expect(data.relays).toContain(relays[1])
+  expect(data.kind).toEqual(30023)
+  expect(data.identifier).toEqual('banana')
+})

nip19.ts

@@ -15,46 +15,75 @@ export type EventPointer = {
   relays?: string[]
 }
 
+export type AddressPointer = {
+  identifier: string
+  pubkey: string
+  kind: number
+  relays?: string[]
+}
+
 export function decode(nip19: string): {
   type: string
-  data: ProfilePointer | EventPointer | string
+  data: ProfilePointer | EventPointer | AddressPointer | string
 } {
   let {prefix, words} = bech32.decode(nip19, Bech32MaxSize)
   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')
+  switch (prefix) {
+    case '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))
+      return {
+        type: 'nprofile',
+        data: {
+          pubkey: secp256k1.utils.bytesToHex(tlv[0][0]),
+          relays: tlv[1].map(d => utf8Decoder.decode(d))
+        }
       }
     }
-  }
+    case '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')
 
-  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))
+      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)}
-  }
+    case 'naddr': {
+      let tlv = parseTLV(data)
+      if (!tlv[0]?.[0]) throw new Error('missing TLV 0 for naddr')
+      if (!tlv[2]?.[0]) throw new Error('missing TLV 2 for naddr')
+      if (tlv[2][0].length !== 32) throw new Error('TLV 2 should be 32 bytes')
+      if (!tlv[3]?.[0]) throw new Error('missing TLV 3 for naddr')
+      if (tlv[3][0].length !== 4) throw new Error('TLV 3 should be 4 bytes')
 
-  throw new Error(`unknown prefix ${prefix}`)
+      return {
+        type: 'naddr',
+        data: {
+          identifier: utf8Decoder.decode(tlv[0][0]),
+          pubkey: secp256k1.utils.bytesToHex(tlv[2][0]),
+          kind: parseInt(secp256k1.utils.bytesToHex(tlv[3][0]), 16),
+          relays: tlv[1].map(d => utf8Decoder.decode(d))
+        }
+      }
+    }
+
+    case 'nsec':
+    case 'npub':
+    case 'note':
+      return {type: prefix, data: secp256k1.utils.bytesToHex(data)}
+
+    default:
+      throw new Error(`unknown prefix ${prefix}`)
+  }
 }
 
 type TLV = {[t: number]: Uint8Array[]}
@@ -110,6 +139,20 @@ export function neventEncode(event: EventPointer): string {
   return bech32.encode('nevent', words, Bech32MaxSize)
 }
 
+export function naddrEncode(addr: AddressPointer): string {
+  let kind = new ArrayBuffer(4)
+  new DataView(kind).setUint32(0, addr.kind, false)
+
+  let data = encodeTLV({
+    0: [utf8Encoder.encode(addr.identifier)],
+    1: (addr.relays || []).map(url => utf8Encoder.encode(url)),
+    2: [secp256k1.utils.hexToBytes(addr.pubkey)],
+    3: [new Uint8Array(kind)]
+  })
+  let words = bech32.toWords(data)
+  return bech32.encode('naddr', words, Bech32MaxSize)
+}
+
 function encodeTLV(tlv: TLV): Uint8Array {
   let entries: Uint8Array[] = []
 

nip57.ts

@@ -1,6 +1,6 @@
 import {bech32} from '@scure/base'
 
-import {Event, EventTemplate} from './event'
+import {Event, EventTemplate, validateEvent, verifySignature} from './event'
 import {utf8Decoder} from './utils'
 
 var _fetch: any
@@ -50,17 +50,20 @@ export function makeZapRequest({
 }: {
   profile: string
   event: string | null
-  amount: string
+  amount: number
   comment: string
   relays: string[]
 }): EventTemplate {
+  if (!amount) throw new Error('amount not given')
+  if (!profile) throw new Error('profile not given')
+
   let zr = {
     kind: 9734,
     created_at: Math.round(Date.now() / 1000),
     content: comment,
     tags: [
       ['p', profile],
-      ['amount', amount],
+      ['amount', amount.toString()],
       ['relays', ...relays]
     ]
   }
@@ -72,6 +75,34 @@ export function makeZapRequest({
   return zr
 }
 
+export function validateZapRequest(zapRequestString: string): string | null {
+  let zapRequest: Event
+
+  try {
+    zapRequest = JSON.parse(zapRequestString)
+  } catch (err) {
+    return 'Invalid zap request JSON.'
+  }
+
+  if (!validateEvent(zapRequest))
+    return 'Zap request is not a valid Nostr event.'
+  if (!verifySignature(zapRequest)) return 'Invalid signature on zap request.'
+
+  let p = zapRequest.tags.find(([t, v]) => t === 'p' && v)
+  if (!p) return "Zap request doesn't have a 'p' tag."
+  if (!p[1].match(/^[a-f0-9]{64}$/))
+    return "Zap request 'p' tag is not valid hex."
+
+  let e = zapRequest.tags.find(([t, v]) => t === 'e' && v)
+  if (e && !e[1].match(/^[a-f0-9]{64}$/))
+    return "Zap request 'e' tag is not valid hex."
+
+  let relays = zapRequest.tags.find(([t, v]) => t === 'relays' && v)
+  if (!relays) return "Zap request doesn't have a 'relays' tag."
+
+  return null
+}
+
 export function makeZapReceipt({
   zapRequest,
   preimage,

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",