ensure types are emitted when publishing.

Co-authored-by: fiatjaf_ <fiatjaf@gmail.com>

.eslintrc.json

@@ -139,13 +139,5 @@
     "wrap-iife": [2, "any"],
     "yield-star-spacing": [2, "both"],
     "yoda": [0]
-  },
-  "overrides": [
-    {
-      "files": ["**/*.test.ts"],
-      "env": { "jest/globals": true },
-      "plugins": ["jest"],
-      "extends": ["plugin:jest/recommended"]
-    }
-  ]
+  }
 }

.github/workflows/npm-publish.yml

@@ -1,23 +0,0 @@
-name: publish npm package
-
-on:
-  push:
-    tags: [v*]
-
-jobs:
-  publish-npm:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-      - uses: extractions/setup-just@v1
-      - run: just install-dependencies
-      - run: just build
-      - run: just test
-      - run: just emit-types
-      - uses: JS-DevTools/npm-publish@v1
-        with:
-          token: ${{ secrets.NPM_TOKEN }}
-          greater-version-only: true

.github/workflows/test.yml

@@ -10,19 +10,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
+      - uses: oven-sh/setup-bun@v1
       - uses: extractions/setup-just@v1
-      - run: just install-dependencies
+      - run: bun i
       - run: just test
   format:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
+      - uses: oven-sh/setup-bun@v1
       - uses: extractions/setup-just@v1
-      - run: just install-dependencies
+      - run: bun i
       - run: just lint

README.md

@@ -1,4 +1,4 @@
-# nostr-tools
+# ![](https://img.shields.io/github/actions/workflow/status/nbd-wtf/nostr-tools/test.yml) nostr-tools
 
 Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
@@ -19,62 +19,51 @@ If using TypeScript, this package requires TypeScript >= 5.0.
 ### Generating a private key and a public key
 
 ```js
-import { generatePrivateKey, getPublicKey } from 'nostr-tools'
+import { generateSecretKey, getPublicKey } from 'nostr-tools'
 
-let sk = generatePrivateKey() // `sk` is a hex string
+let sk = generateSecretKey() // `sk` is a hex string
 let pk = getPublicKey(sk) // `pk` is a hex string
 ```
 
 ### Creating, signing and verifying events
 
 ```js
-import { validateEvent, verifySignature, getSignature, getEventHash, getPublicKey } from 'nostr-tools'
+import { finalizeEvent, verifyEvent } from 'nostr-tools'
 
-let event = {
+let event = finalizeEvent({
   kind: 1,
   created_at: Math.floor(Date.now() / 1000),
   tags: [],
   content: 'hello',
-  pubkey: getPublicKey(privateKey),
-}
+}, sk)
 
-event.id = getEventHash(event)
-event.sig = getSignature(event, privateKey)
-
-let ok = validateEvent(event)
-let veryOk = verifySignature(event)
+let isGood = verifyEvent(event)
 ```
 
 ### Interacting with a relay
 
 ```js
-import { relayInit, finishEvent, generatePrivateKey, getPublicKey } from 'nostr-tools'
+import { relayConnect, finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools'
 
-const relay = relayInit('wss://relay.example.com')
-relay.on('connect', () => {
-  console.log(`connected to ${relay.url}`)
-})
-relay.on('error', () => {
-  console.log(`failed to connect to ${relay.url}`)
-})
-
-await relay.connect()
+const relay = await relayConnect('wss://relay.example.com')
+console.log(`connected to ${relay.url}`)
 
 // let's query for an event that exists
-let sub = relay.sub([
+const sub = relay.subscribe([
   {
     ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
   },
-])
-sub.on('event', event => {
-  console.log('we got the event we wanted:', event)
-})
-sub.on('eose', () => {
-  sub.unsub()
+], {
+  onevent(event) {
+    console.log('we got the event we wanted:', event)
+  },
+  oneose() {
+    sub.close()
+  }
 })
 
 // let's publish a new event while simultaneously monitoring the relay for it
-let sk = generatePrivateKey()
+let sk = generateSecretKey()
 let pk = getPublicKey(sk)
 
 let sub = relay.sub([
@@ -96,7 +85,7 @@ let event = {
 }
 
 // this assigns the pubkey, calculates the event id and signs the event in a single step
-const signedEvent = finishEvent(event, sk)
+const signedEvent = finalizeEvent(event, sk)
 await relay.publish(signedEvent)
 
 let events = await relay.list([{ kinds: [0, 1] }])
@@ -122,41 +111,33 @@ const pool = new SimplePool()
 
 let relays = ['wss://relay.example.com', 'wss://relay.example2.com']
 
-let sub = pool.sub(
+let h = pool.subscribeMany(
   [...relays, 'wss://relay.example3.com'],
   [
     {
       authors: ['32e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'],
     },
   ],
+  {
+    onevent(event) {
+      // this will only be called once the first time the event is received
+      // ...
+    },
+    oneose() {
+      h.close()
+    }
+  }
 )
 
-sub.on('event', event => {
-  // this will only be called once the first time the event is received
-  // ...
-})
+await Promise.any(pool.publish(relays, newEvent))
+console.log('published to at least one relay!')
 
-let pubs = pool.publish(relays, newEvent)
-await Promise.all(pubs)
-
-let events = await pool.list(relays, [{ kinds: [0, 1] }])
+let events = await pool.querySync(relays, [{ kinds: [0, 1] }])
 let event = await pool.get(relays, {
   ids: ['44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245'],
 })
-
-let batchedEvents = await pool.batchedList('notes', relays, [{ kinds: [1] }])
-// `batchedList` will wait for other function calls with the same `batchKey`
-// (e.g. 'notes', 'authors', etc) within a fixed amount of time (default: `100ms`) before sending
-// next ws request, and batch all requests with similar `batchKey`s together in a single request.
-
-let relaysForEvent = pool.seenOn('44e1827635450ebb3c5a7d12c1f8e7b2b514439ac10a67eef3d9fd9c5c68e245')
-// relaysForEvent will be an array of URLs from relays a given event was seen on
-
-pool.close()
 ```
 
-read more details about `batchedList` on this pr: [https://github.com/nbd-wtf/nostr-tools/pull/279](https://github.com/nbd-wtf/nostr-tools/pull/279#issue-1859315757)
-
 ### Parsing references (mentions) from a content using NIP-10 and NIP-27
 
 ```js
@@ -198,21 +179,21 @@ nip05.useFetchImplementation(require('node-fetch'))
 ### Encoding and decoding NIP-19 codes
 
 ```js
-import { nip19, generatePrivateKey, getPublicKey } from 'nostr-tools'
+import { nip19, generateSecretKey, getPublicKey } from 'nostr-tools'
 
-let sk = generatePrivateKey()
+let sk = generateSecretKey()
 let nsec = nip19.nsecEncode(sk)
 let { type, data } = nip19.decode(nsec)
 assert(type === 'nsec')
 assert(data === sk)
 
-let pk = getPublicKey(generatePrivateKey())
+let pk = getPublicKey(generateSecretKey())
 let npub = nip19.npubEncode(pk)
 let { type, data } = nip19.decode(npub)
 assert(type === 'npub')
 assert(data === pk)
 
-let pk = getPublicKey(generatePrivateKey())
+let pk = getPublicKey(generateSecretKey())
 let relays = ['wss://relay.nostr.example.mydomain.example.com', 'wss://nostr.banana.com']
 let nprofile = nip19.nprofileEncode({ pubkey: pk, relays })
 let { type, data } = nip19.decode(nprofile)
@@ -221,93 +202,48 @@ assert(data.pubkey === pk)
 assert(data.relays.length === 2)
 ```
 
-### Encrypting and decrypting direct messages
+## Import modes
+
+### Using just the packages you want
+
+Importing the entirety of `nostr-tools` may bloat your build, so you should probably import individual packages instead:
 
 ```js
-import {nip44, getPublicKey, generatePrivateKey} from 'nostr-tools'
-
-// sender
-let sk1 = generatePrivateKey()
-let pk1 = getPublicKey(sk1)
-
-// receiver
-let sk2 = generatePrivateKey()
-let pk2 = getPublicKey(sk2)
-
-// on the sender side
-let message = 'hello'
-let key = nip44.getSharedSecret(sk1, pk2)
-let ciphertext = nip44.encrypt(key, message)
-
-let event = {
-  kind: 4,
-  pubkey: pk1,
-  tags: [['p', pk2]],
-  content: ciphertext,
-  ...otherProperties,
-}
-
-sendEvent(event)
-
-// on the receiver side
-sub.on('event', async event => {
-  let sender = event.pubkey
-  // pk1 === sender
-  let _key = nip44.getSharedSecret(sk2, pk1)
-  let plaintext = nip44.decrypt(_key, event.content)
-})
+import { generateSecretKey, finalizeEvent, verifyEvent } from 'nostr-tools/pure'
+import { matchFilter } from 'nostr-tools/filter'
+import { decode, nprofileEncode, neventEncode, npubEncode } from 'nostr-tools/nip19'
+// and so on and so forth
 ```
 
-### Performing and checking for delegation
+### Using it with `nostr-wasm`
+
+[`nostr-wasm`](https://github.com/fiatjaf/nostr-wasm) is a thin wrapper over [libsecp256k1](https://github.com/bitcoin-core/secp256k1) compiled to WASM just for hashing, signing and verifying Nostr events.
 
 ```js
-import { nip26, getPublicKey, generatePrivateKey } from 'nostr-tools'
+import { setNostrWasm, generateSecretKey, finalizeEvent, verifyEvent } from 'nostr-tools/wasm'
+import { initNostrWasm } from 'nostr-wasm'
 
-// delegator
-let sk1 = generatePrivateKey()
-let pk1 = getPublicKey(sk1)
+// make sure this promise resolves before your app starts calling finalizeEvent or verifyEvent
+initNostrWasm().then(setNostrWasm)
 
-// delegatee
-let sk2 = generatePrivateKey()
-let pk2 = getPublicKey(sk2)
-
-// generate delegation
-let delegation = nip26.createDelegation(sk1, {
-  pubkey: pk2,
-  kind: 1,
-  since: Math.round(Date.now() / 1000),
-  until: Math.round(Date.now() / 1000) + 60 * 60 * 24 * 30 /* 30 days */,
-})
-
-// the delegatee uses the delegation when building an event
-let event = {
-  pubkey: pk2,
-  kind: 1,
-  created_at: Math.round(Date.now() / 1000),
-  content: 'hello from a delegated key',
-  tags: [['delegation', delegation.from, delegation.cond, delegation.sig]],
-}
-
-// finally any receiver of this event can check for the presence of a valid delegation tag
-let delegator = nip26.getDelegator(event)
-assert(delegator === pk1) // will be null if there is no delegation tag or if it is invalid
+// or use 'nostr-wasm/gzipped' or even 'nostr-wasm/headless',
+// see https://www.npmjs.com/package/nostr-wasm for options
 ```
 
-Please consult the tests or [the source code](https://github.com/fiatjaf/nostr-tools) for more information that isn't available here.
+This may be faster than the pure-JS [noble libraries](https://paulmillr.com/noble/) used by default and in `nostr-tools/pure`.
 
 ### Using from the browser (if you don't want to use a bundler)
 
 ```html
 <script src="https://unpkg.com/nostr-tools/lib/nostr.bundle.js"></script>
 <script>
-  window.NostrTools.generatePrivateKey('...') // and so on
+  window.NostrTools.generateSecretKey('...') // and so on
 </script>
 ```
 
 ## Plumbing
 
-1. Install [`just`](https://just.systems/)
-2. `just -l`
+To develop `nostr-tools`, install [`just`](https://just.systems/) and run `just -l` to see commands available.
 
 ## License
 

build.js

@@ -1,15 +1,18 @@
-#!/usr/bin/env node
-
-const fs = require('fs')
+const fs = require('node:fs')
 const esbuild = require('esbuild')
-const { join } = require('path');
+const { join } = require('path')
 
-const entryPoints = fs.readdirSync(process.cwd())
+const entryPoints = fs
+  .readdirSync(process.cwd())
   .filter(
-    (file) =>
-      file.endsWith(".ts") && !file.endsWith("test.ts") &&
-      fs.statSync(join(process.cwd(), file)).isFile()
-  );
+    file =>
+      file.endsWith('.ts') &&
+      file !== 'core.ts' &&
+      file !== 'test-helpers.ts' &&
+      file !== 'helpers.ts' &&
+      !file.endsWith('.test.ts') &&
+      fs.statSync(join(process.cwd(), file)).isFile(),
+  )
 
 let common = {
   entryPoints,

core.test.ts

@@ -0,0 +1,293 @@
+import { describe, test, expect } from 'bun:test'
+
+import {
+  finalizeEvent,
+  serializeEvent,
+  getEventHash,
+  validateEvent,
+  verifyEvent,
+  verifiedSymbol,
+  getPublicKey,
+  generateSecretKey,
+} from './pure.ts'
+import { ShortTextNote } from './kinds.ts'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
+
+test('private key generation', () => {
+  expect(bytesToHex(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
+})
+
+test('public key generation', () => {
+  expect(getPublicKey(generateSecretKey())).toMatch(/[a-f0-9]{64}/)
+})
+
+test('public key from private key deterministic', () => {
+  let sk = generateSecretKey()
+  let pk = getPublicKey(sk)
+
+  for (let i = 0; i < 5; i++) {
+    expect(getPublicKey(sk)).toEqual(pk)
+  }
+})
+
+describe('finalizeEvent', () => {
+  test('should create a signed event from a template', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const template = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+    }
+
+    const event = finalizeEvent(template, privateKey)
+
+    expect(event.kind).toEqual(template.kind)
+    expect(event.tags).toEqual(template.tags)
+    expect(event.content).toEqual(template.content)
+    expect(event.created_at).toEqual(template.created_at)
+    expect(event.pubkey).toEqual(publicKey)
+    expect(typeof event.id).toEqual('string')
+    expect(typeof event.sig).toEqual('string')
+  })
+})
+
+describe('serializeEvent', () => {
+  test('should serialize a valid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      pubkey: publicKey,
+      created_at: 1617932115,
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+    }
+
+    const serializedEvent = serializeEvent(unsignedEvent)
+
+    expect(serializedEvent).toEqual(
+      JSON.stringify([
+        0,
+        publicKey,
+        unsignedEvent.created_at,
+        unsignedEvent.kind,
+        unsignedEvent.tags,
+        unsignedEvent.content,
+      ]),
+    )
+  })
+
+  test('should throw an error for an invalid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      created_at: 1617932115,
+      pubkey: publicKey, // missing content
+    }
+
+    expect(() => {
+      // @ts-expect-error
+      serializeEvent(invalidEvent)
+    }).toThrow("can't serialize event with wrong or missing properties")
+  })
+})
+
+describe('getEventHash', () => {
+  test('should return the correct event hash', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const eventHash = getEventHash(unsignedEvent)
+
+    expect(typeof eventHash).toEqual('string')
+    expect(eventHash.length).toEqual(64)
+  })
+})
+
+describe('validateEvent', () => {
+  test('should return true for a valid event object', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const unsignedEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(unsignedEvent)
+
+    expect(isValid).toEqual(true)
+  })
+
+  test('should return false for a non object event', () => {
+    const nonObjectEvent = ''
+    const isValid = validateEvent(nonObjectEvent)
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an event object with missing properties', () => {
+    const invalidEvent = {
+      kind: ShortTextNote,
+      tags: [],
+      created_at: 1617932115, // missing content and pubkey
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an empty object', () => {
+    const emptyObj = {}
+
+    const isValid = validateEvent(emptyObj)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with invalid properties', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: 1,
+      tags: [],
+      created_at: '1617932115', // should be a number
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with an invalid public key', () => {
+    const invalidEvent = {
+      kind: 1,
+      tags: [],
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: 'invalid_pubkey',
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an object with invalid tags', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const publicKey = getPublicKey(privateKey)
+
+    const invalidEvent = {
+      kind: 1,
+      tags: {}, // should be an array
+      content: 'Hello, world!',
+      created_at: 1617932115,
+      pubkey: publicKey,
+    }
+
+    const isValid = validateEvent(invalidEvent)
+
+    expect(isValid).toEqual(false)
+  })
+})
+
+describe('verifyEvent', () => {
+  test('should return true for a valid event signature', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const event = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(true)
+  })
+
+  test('should return false for an invalid event signature', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    // tamper with the signature
+    event.sig = event.sig.replace(/^.{3}/g, '666')
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false when verifying an event with a different private key', () => {
+    const privateKey1 = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+
+    const privateKey2 = hexToBytes('5b4a34f4e4b23c63ad55a35e3f84a3b53d96dbf266edf521a8358f71d19cbf67')
+    const publicKey2 = getPublicKey(privateKey2)
+
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: ShortTextNote,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey1,
+    )
+
+    // verify with different private key
+    const isValid = verifyEvent({
+      ...event,
+      pubkey: publicKey2,
+    })
+    expect(isValid).toEqual(false)
+  })
+
+  test('should return false for an invalid event id', () => {
+    const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
+
+    const { [verifiedSymbol]: _, ...event } = finalizeEvent(
+      {
+        kind: 1,
+        tags: [],
+        content: 'Hello, world!',
+        created_at: 1617932115,
+      },
+      privateKey,
+    )
+
+    // tamper with the id
+    event.id = event.id.replace(/^.{3}/g, '666')
+
+    const isValid = verifyEvent(event)
+    expect(isValid).toEqual(false)
+  })
+})

core.ts

@@ -0,0 +1,50 @@
+export interface Nostr {
+  generateSecretKey(): Uint8Array
+  getPublicKey(secretKey: Uint8Array): string
+  finalizeEvent(event: EventTemplate, secretKey: Uint8Array): VerifiedEvent
+  verifyEvent(event: Event): event is VerifiedEvent
+}
+
+/** Designates a verified event signature. */
+export const verifiedSymbol = Symbol('verified')
+
+export interface Event {
+  kind: number
+  tags: string[][]
+  content: string
+  created_at: number
+  pubkey: string
+  id: string
+  sig: string
+  [verifiedSymbol]?: boolean
+}
+
+export type EventTemplate = Pick<Event, 'kind' | 'tags' | 'content' | 'created_at'>
+export type UnsignedEvent = Pick<Event, 'kind' | 'tags' | 'content' | 'created_at' | 'pubkey'>
+
+/** An event whose signature has been verified. */
+export interface VerifiedEvent extends Event {
+  [verifiedSymbol]: true
+}
+
+const isRecord = (obj: unknown): obj is Record<string, unknown> => obj instanceof Object
+
+export function validateEvent<T>(event: T): event is T & UnsignedEvent {
+  if (!isRecord(event)) return false
+  if (typeof event.kind !== 'number') return false
+  if (typeof event.content !== 'string') return false
+  if (typeof event.created_at !== 'number') return false
+  if (typeof event.pubkey !== 'string') return false
+  if (!event.pubkey.match(/^[a-f0-9]{64}$/)) return false
+
+  if (!Array.isArray(event.tags)) return false
+  for (let i = 0; i < event.tags.length; i++) {
+    let tag = event.tags[i]
+    if (!Array.isArray(tag)) return false
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] === 'object') return false
+    }
+  }
+
+  return true
+}

event.test.ts

@@ -1,360 +0,0 @@
-import {
-  getBlankEvent,
-  finishEvent,
-  serializeEvent,
-  getEventHash,
-  validateEvent,
-  verifySignature,
-  getSignature,
-  Kind,
-  verifiedSymbol,
-} from './event.ts'
-import { getPublicKey } from './keys.ts'
-
-describe('Event', () => {
-  describe('getBlankEvent', () => {
-    it('should return a blank event object', () => {
-      expect(getBlankEvent(255)).toEqual({
-        kind: 255,
-        content: '',
-        tags: [],
-        created_at: 0,
-      })
-    })
-
-    it('should return a blank event object with defined kind', () => {
-      expect(getBlankEvent(Kind.Text)).toEqual({
-        kind: 1,
-        content: '',
-        tags: [],
-        created_at: 0,
-      })
-    })
-  })
-
-  describe('finishEvent', () => {
-    it('should create a signed event from a template', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const template = {
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-      }
-
-      const event = finishEvent(template, privateKey)
-
-      expect(event.kind).toEqual(template.kind)
-      expect(event.tags).toEqual(template.tags)
-      expect(event.content).toEqual(template.content)
-      expect(event.created_at).toEqual(template.created_at)
-      expect(event.pubkey).toEqual(publicKey)
-      expect(typeof event.id).toEqual('string')
-      expect(typeof event.sig).toEqual('string')
-    })
-  })
-
-  describe('serializeEvent', () => {
-    it('should serialize a valid event object', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const unsignedEvent = {
-        pubkey: publicKey,
-        created_at: 1617932115,
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-      }
-
-      const serializedEvent = serializeEvent(unsignedEvent)
-
-      expect(serializedEvent).toEqual(
-        JSON.stringify([
-          0,
-          publicKey,
-          unsignedEvent.created_at,
-          unsignedEvent.kind,
-          unsignedEvent.tags,
-          unsignedEvent.content,
-        ]),
-      )
-    })
-
-    it('should throw an error for an invalid event object', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const invalidEvent = {
-        kind: Kind.Text,
-        tags: [],
-        created_at: 1617932115,
-        pubkey: publicKey, // missing content
-      }
-
-      expect(() => {
-        // @ts-expect-error
-        serializeEvent(invalidEvent)
-      }).toThrow("can't serialize event with wrong or missing properties")
-    })
-  })
-
-  describe('getEventHash', () => {
-    it('should return the correct event hash', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const unsignedEvent = {
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: publicKey,
-      }
-
-      const eventHash = getEventHash(unsignedEvent)
-
-      expect(typeof eventHash).toEqual('string')
-      expect(eventHash.length).toEqual(64)
-    })
-  })
-
-  describe('validateEvent', () => {
-    it('should return true for a valid event object', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const unsignedEvent = {
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: publicKey,
-      }
-
-      const isValid = validateEvent(unsignedEvent)
-
-      expect(isValid).toEqual(true)
-    })
-
-    it('should return false for a non object event', () => {
-      const nonObjectEvent = ''
-
-      const isValid = validateEvent(nonObjectEvent)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an event object with missing properties', () => {
-      const invalidEvent = {
-        kind: Kind.Text,
-        tags: [],
-        created_at: 1617932115, // missing content and pubkey
-      }
-
-      const isValid = validateEvent(invalidEvent)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an empty object', () => {
-      const emptyObj = {}
-
-      const isValid = validateEvent(emptyObj)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an object with invalid properties', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const invalidEvent = {
-        kind: 1,
-        tags: [],
-        created_at: '1617932115', // should be a number
-        pubkey: publicKey,
-      }
-
-      const isValid = validateEvent(invalidEvent)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an object with an invalid public key', () => {
-      const invalidEvent = {
-        kind: 1,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: 'invalid_pubkey',
-      }
-
-      const isValid = validateEvent(invalidEvent)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an object with invalid tags', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const invalidEvent = {
-        kind: 1,
-        tags: {}, // should be an array
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: publicKey,
-      }
-
-      const isValid = validateEvent(invalidEvent)
-
-      expect(isValid).toEqual(false)
-    })
-  })
-
-  describe('verifySignature', () => {
-    it('should return true for a valid event signature', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
-      const event = finishEvent(
-        {
-          kind: Kind.Text,
-          tags: [],
-          content: 'Hello, world!',
-          created_at: 1617932115,
-        },
-        privateKey,
-      )
-
-      const isValid = verifySignature(event)
-
-      expect(isValid).toEqual(true)
-    })
-
-    it('should return false for an invalid event signature', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
-      const { [verifiedSymbol]: _, ...event } = finishEvent(
-        {
-          kind: Kind.Text,
-          tags: [],
-          content: 'Hello, world!',
-          created_at: 1617932115,
-        },
-        privateKey,
-      )
-
-      // tamper with the signature
-      event.sig = event.sig.replace(/^.{3}/g, '666')
-
-      const isValid = verifySignature(event)
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false when verifying an event with a different private key', () => {
-      const privateKey1 = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
-      const privateKey2 = '5b4a34f4e4b23c63ad55a35e3f84a3b53d96dbf266edf521a8358f71d19cbf67'
-      const publicKey2 = getPublicKey(privateKey2)
-
-      const { [verifiedSymbol]: _, ...event } = finishEvent(
-        {
-          kind: Kind.Text,
-          tags: [],
-          content: 'Hello, world!',
-          created_at: 1617932115,
-        },
-        privateKey1,
-      )
-
-      // verify with different private key
-      const isValid = verifySignature({
-        ...event,
-        pubkey: publicKey2,
-      })
-
-      expect(isValid).toEqual(false)
-    })
-
-    it('should return false for an invalid event id', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
-      const { [verifiedSymbol]: _, ...event } = finishEvent(
-        {
-          kind: 1,
-          tags: [],
-          content: 'Hello, world!',
-          created_at: 1617932115,
-        },
-        privateKey,
-      )
-
-      // tamper with the id
-      event.id = event.id.replace(/^.{3}/g, '666')
-
-      const isValid = verifySignature(event)
-
-      expect(isValid).toEqual(false)
-    })
-  })
-
-  describe('getSignature', () => {
-    it('should produce the correct signature for an event object', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const unsignedEvent = {
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: publicKey,
-      }
-
-      const sig = getSignature(unsignedEvent, privateKey)
-
-      // verify the signature
-      const isValid = verifySignature({
-        ...unsignedEvent,
-        id: getEventHash(unsignedEvent),
-        sig,
-      })
-
-      expect(typeof sig).toEqual('string')
-      expect(sig.length).toEqual(128)
-      expect(isValid).toEqual(true)
-    })
-
-    it('should not sign an event with different private key', () => {
-      const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-      const publicKey = getPublicKey(privateKey)
-
-      const wrongPrivateKey = 'a91e2a9d9e0f70f0877bea0dbf034e8f95d7392a27a7f07da0d14b9e9d456be7'
-
-      const unsignedEvent = {
-        kind: Kind.Text,
-        tags: [],
-        content: 'Hello, world!',
-        created_at: 1617932115,
-        pubkey: publicKey,
-      }
-
-      const sig = getSignature(unsignedEvent, wrongPrivateKey)
-
-      // verify the signature
-      // @ts-expect-error
-      const isValid = verifySignature({
-        ...unsignedEvent,
-        sig,
-      })
-
-      expect(typeof sig).toEqual('string')
-      expect(sig.length).toEqual(128)
-      expect(isValid).toEqual(false)
-    })
-  })
-})

event.ts

@@ -1,140 +0,0 @@
-import { schnorr } from '@noble/curves/secp256k1'
-import { sha256 } from '@noble/hashes/sha256'
-import { bytesToHex } from '@noble/hashes/utils'
-
-import { getPublicKey } from './keys.ts'
-import { utf8Encoder } from './utils.ts'
-
-/** Designates a verified event signature. */
-export const verifiedSymbol = Symbol('verified')
-
-export const Kind = {
-  Metadata: 0,
-  Text: 1,
-  RecommendRelay: 2,
-  Contacts: 3,
-  EncryptedDirectMessage: 4,
-  EventDeletion: 5,
-  Repost: 6,
-  Reaction: 7,
-  BadgeAward: 8,
-  ChannelCreation: 40,
-  ChannelMetadata: 41,
-  ChannelMessage: 42,
-  ChannelHideMessage: 43,
-  ChannelMuteUser: 44,
-  Blank: 255,
-  Report: 1984,
-  ZapRequest: 9734,
-  Zap: 9735,
-  RelayList: 10002,
-  ClientAuth: 22242,
-  NwcRequest: 23194,
-  HttpAuth: 27235,
-  ProfileBadge: 30008,
-  BadgeDefinition: 30009,
-  Article: 30023,
-  FileMetadata: 1063,
-} as const
-
-export interface Event<K extends number = number> {
-  kind: K
-  tags: string[][]
-  content: string
-  created_at: number
-  pubkey: string
-  id: string
-  sig: string
-  [verifiedSymbol]?: boolean
-}
-
-export type EventTemplate<K extends number = number> = Pick<Event<K>, 'kind' | 'tags' | 'content' | 'created_at'>
-export type UnsignedEvent<K extends number = number> = Pick<
-  Event<K>,
-  'kind' | 'tags' | 'content' | 'created_at' | 'pubkey'
->
-
-/** An event whose signature has been verified. */
-export interface VerifiedEvent<K extends number = number> extends Event<K> {
-  [verifiedSymbol]: true
-}
-
-export function getBlankEvent(kind: number = 255): EventTemplate {
-  return {
-    kind,
-    content: '',
-    tags: [],
-    created_at: 0,
-  }
-}
-
-export function finishEvent<K extends number = number>(t: EventTemplate<K>, privateKey: string): VerifiedEvent<K> {
-  const event = t as VerifiedEvent<K>
-  event.pubkey = getPublicKey(privateKey)
-  event.id = getEventHash(event)
-  event.sig = getSignature(event, privateKey)
-  event[verifiedSymbol] = true
-  return event
-}
-
-export function serializeEvent(evt: UnsignedEvent<number>): string {
-  if (!validateEvent(evt)) throw new Error("can't serialize event with wrong or missing properties")
-
-  return JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content])
-}
-
-export function getEventHash(event: UnsignedEvent<number>): string {
-  let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
-  return bytesToHex(eventHash)
-}
-
-const isRecord = (obj: unknown): obj is Record<string, unknown> => obj instanceof Object
-
-export function validateEvent<T>(event: T): event is T & UnsignedEvent<number> {
-  if (!isRecord(event)) return false
-  if (typeof event.kind !== 'number') return false
-  if (typeof event.content !== 'string') return false
-  if (typeof event.created_at !== 'number') return false
-  if (typeof event.pubkey !== 'string') return false
-  if (!event.pubkey.match(/^[a-f0-9]{64}$/)) return false
-
-  if (!Array.isArray(event.tags)) return false
-  for (let i = 0; i < event.tags.length; i++) {
-    let tag = event.tags[i]
-    if (!Array.isArray(tag)) return false
-    for (let j = 0; j < tag.length; j++) {
-      if (typeof tag[j] === 'object') return false
-    }
-  }
-
-  return true
-}
-
-/** Verify the event's signature. This function mutates the event with a `verified` symbol, making it idempotent. */
-export function verifySignature<K extends number>(event: Event<K>): event is VerifiedEvent<K> {
-  if (typeof event[verifiedSymbol] === 'boolean') return event[verifiedSymbol]
-
-  const hash = getEventHash(event)
-  if (hash !== event.id) {
-    return (event[verifiedSymbol] = false)
-  }
-
-  try {
-    return (event[verifiedSymbol] = schnorr.verify(event.sig, hash, event.pubkey))
-  } catch (err) {
-    return (event[verifiedSymbol] = false)
-  }
-}
-
-/** @deprecated Use `getSignature` instead. */
-export function signEvent(event: UnsignedEvent<number>, key: string): string {
-  console.warn(
-    'nostr-tools: `signEvent` is deprecated and will be removed or changed in the future. Please use `getSignature` instead.',
-  )
-  return getSignature(event, key)
-}
-
-/** Calculate the signature for an event. */
-export function getSignature(event: UnsignedEvent<number>, key: string): string {
-  return bytesToHex(schnorr.sign(getEventHash(event), key))
-}

fakejson.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { matchEventId, matchEventKind, getSubscriptionId } from './fakejson.ts'
 
 test('match id', () => {

filter.test.ts

@@ -1,9 +1,10 @@
+import { describe, test, expect } from 'bun:test'
 import { matchFilter, matchFilters, mergeFilters } from './filter.ts'
 import { buildEvent } from './test-helpers.ts'
 
 describe('Filter', () => {
   describe('matchFilter', () => {
-    it('should return true when all filter conditions are met', () => {
+    test('should return true when all filter conditions are met', () => {
       const filter = {
         ids: ['123', '456'],
         kinds: [1, 2, 3],
@@ -26,7 +27,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return false when the event id is not in the filter', () => {
+    test('should return false when the event id is not in the filter', () => {
       const filter = { ids: ['123', '456'] }
 
       const event = buildEvent({ id: '789' })
@@ -36,7 +37,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return true when the event id starts with a prefix', () => {
+    test('should return true when the event id starts with a prefix', () => {
       const filter = { ids: ['22', '00'] }
 
       const event = buildEvent({ id: '001' })
@@ -46,7 +47,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return false when the event kind is not in the filter', () => {
+    test('should return false when the event kind is not in the filter', () => {
       const filter = { kinds: [1, 2, 3] }
 
       const event = buildEvent({ kind: 4 })
@@ -56,7 +57,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return false when the event author is not in the filter', () => {
+    test('should return false when the event author is not in the filter', () => {
       const filter = { authors: ['abc', 'def'] }
 
       const event = buildEvent({ pubkey: 'ghi' })
@@ -66,7 +67,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return false when a tag is not present in the event', () => {
+    test('should return false when a tag is not present in the event', () => {
       const filter = { '#tag': ['value1', 'value2'] }
 
       const event = buildEvent({ tags: [['not_tag', 'value1']] })
@@ -76,7 +77,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return false when a tag value is not present in the event', () => {
+    test('should return false when a tag value is not present in the event', () => {
       const filter = { '#tag': ['value1', 'value2'] }
 
       const event = buildEvent({ tags: [['tag', 'value3']] })
@@ -86,7 +87,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return true when filter has tags that is present in the event', () => {
+    test('should return true when filter has tags that is present in the event', () => {
       const filter = { '#tag1': ['foo'] }
 
       const event = buildEvent({
@@ -105,7 +106,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return false when the event is before the filter since value', () => {
+    test('should return false when the event is before the filter since value', () => {
       const filter = { since: 100 }
 
       const event = buildEvent({ created_at: 50 })
@@ -115,7 +116,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return true when the timestamp of event is equal to the filter since value', () => {
+    test('should return true when the timestamp of event is equal to the filter since value', () => {
       const filter = { since: 100 }
 
       const event = buildEvent({ created_at: 100 })
@@ -125,7 +126,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return false when the event is after the filter until value', () => {
+    test('should return false when the event is after the filter until value', () => {
       const filter = { until: 100 }
 
       const event = buildEvent({ created_at: 150 })
@@ -135,7 +136,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return true when the timestamp of event is equal to the filter until value', () => {
+    test('should return true when the timestamp of event is equal to the filter until value', () => {
       const filter = { until: 100 }
 
       const event = buildEvent({ created_at: 100 })
@@ -147,7 +148,7 @@ describe('Filter', () => {
   })
 
   describe('matchFilters', () => {
-    it('should return true when at least one filter matches the event', () => {
+    test('should return true when at least one filter matches the event', () => {
       const filters = [
         { ids: ['123'], kinds: [1], authors: ['abc'] },
         { ids: ['456'], kinds: [2], authors: ['def'] },
@@ -161,7 +162,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return true when at least one prefix matches the event', () => {
+    test('should return true when at least one prefix matches the event', () => {
       const filters = [
         { ids: ['1'], kinds: [1], authors: ['a'] },
         { ids: ['4'], kinds: [2], authors: ['d'] },
@@ -175,7 +176,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return true when event matches one or more filters and some have limit set', () => {
+    test('should return true when event matches one or more filters and some have limit set', () => {
       const filters = [
         { ids: ['123'], limit: 1 },
         { kinds: [1], limit: 2 },
@@ -194,7 +195,7 @@ describe('Filter', () => {
       expect(result).toEqual(true)
     })
 
-    it('should return false when no filters match the event', () => {
+    test('should return false when no filters match the event', () => {
       const filters = [
         { ids: ['123'], kinds: [1], authors: ['abc'] },
         { ids: ['456'], kinds: [2], authors: ['def'] },
@@ -208,7 +209,7 @@ describe('Filter', () => {
       expect(result).toEqual(false)
     })
 
-    it('should return false when event matches none of the filters and some have limit set', () => {
+    test('should return false when event matches none of the filters and some have limit set', () => {
       const filters = [
         { ids: ['123'], limit: 1 },
         { kinds: [1], limit: 2 },
@@ -228,7 +229,7 @@ describe('Filter', () => {
   })
 
   describe('mergeFilters', () => {
-    it('should merge filters', () => {
+    test('should merge filters', () => {
       expect(mergeFilters({ ids: ['a', 'b'], limit: 3 }, { authors: ['x'], ids: ['b', 'c'] })).toEqual({
         ids: ['a', 'b', 'c'],
         limit: 3,

filter.ts

@@ -1,8 +1,8 @@
-import { Event } from './event.ts'
+import { Event } from './pure.ts'
 
-export type Filter<K extends number = number> = {
+export type Filter = {
   ids?: string[]
-  kinds?: K[]
+  kinds?: number[]
   authors?: string[]
   since?: number
   until?: number
@@ -11,7 +11,7 @@ export type Filter<K extends number = number> = {
   [key: `#${string}`]: string[] | undefined
 }
 
-export function matchFilter(filter: Filter<number>, event: Event<number>): boolean {
+export function matchFilter(filter: Filter, event: Event): boolean {
   if (filter.ids && filter.ids.indexOf(event.id) === -1) {
     if (!filter.ids.some(prefix => event.id.startsWith(prefix))) {
       return false
@@ -38,15 +38,15 @@ export function matchFilter(filter: Filter<number>, event: Event<number>): boole
   return true
 }
 
-export function matchFilters(filters: Filter<number>[], event: Event<number>): boolean {
+export function matchFilters(filters: Filter[], event: Event): boolean {
   for (let i = 0; i < filters.length; i++) {
     if (matchFilter(filters[i], event)) return true
   }
   return false
 }
 
-export function mergeFilters(...filters: Filter<number>[]): Filter<number> {
-  let result: Filter<number> = {}
+export function mergeFilters(...filters: Filter[]): Filter {
+  let result: Filter = {}
   for (let i = 0; i < filters.length; i++) {
     let filter = filters[i]
     Object.entries(filter).forEach(([property, values]) => {

helpers.ts

@@ -0,0 +1,9 @@
+export async function yieldThread() {
+  return new Promise(resolve => {
+    const ch = new MessageChannel()
+    // @ts-ignore (typescript thinks this property should be called `addListener`, but in fact it's `addEventListener`)
+    ch.port1.addEventListener('message', resolve)
+    ch.port2.postMessage(0)
+    ch.port1.start()
+  })
+}

index.ts

@@ -1,25 +1,24 @@
-export * from './keys.ts'
+export * from './pure.ts'
 export * from './relay.ts'
-export * from './event.ts'
+export * from './pure.ts'
 export * from './filter.ts'
 export * from './pool.ts'
 export * from './references.ts'
 
 export * as nip04 from './nip04.ts'
 export * as nip05 from './nip05.ts'
-export * as nip06 from './nip06.ts'
 export * as nip10 from './nip10.ts'
+export * as nip11 from './nip11.ts'
 export * as nip13 from './nip13.ts'
 export * as nip18 from './nip18.ts'
 export * as nip19 from './nip19.ts'
 export * as nip21 from './nip21.ts'
 export * as nip25 from './nip25.ts'
-export * as nip26 from './nip26.ts'
 export * as nip27 from './nip27.ts'
 export * as nip28 from './nip28.ts'
+export * as nip30 from './nip30.ts'
 export * as nip39 from './nip39.ts'
 export * as nip42 from './nip42.ts'
-export * as nip44 from './nip44.ts'
 export * as nip47 from './nip47.ts'
 export * as nip57 from './nip57.ts'
 export * as nip98 from './nip98.ts'

jest.config.js

@@ -1,5 +0,0 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-}

justfile

@@ -1,17 +1,14 @@
 export PATH := "./node_modules/.bin:" + env_var('PATH')
 
-install-dependencies:
-    yarn --ignore-engines
-
 build:
     rm -rf lib
-    node build.js
+    bun run build.js
 
 test:
-    jest
+    bun test --timeout 20000
 
 test-only file:
-    jest {{file}}
+    bun test {{file}}
 
 emit-types:
     tsc # see tsconfig.json

keys.test.ts

@@ -1,18 +0,0 @@
-import { generatePrivateKey, getPublicKey } from './keys.ts'
-
-test('private key generation', () => {
-  expect(generatePrivateKey()).toMatch(/[a-f0-9]{64}/)
-})
-
-test('public key generation', () => {
-  expect(getPublicKey(generatePrivateKey())).toMatch(/[a-f0-9]{64}/)
-})
-
-test('public key from private key deterministic', () => {
-  let sk = generatePrivateKey()
-  let pk = getPublicKey(sk)
-
-  for (let i = 0; i < 5; i++) {
-    expect(getPublicKey(sk)).toEqual(pk)
-  }
-})

keys.ts

@@ -1,10 +0,0 @@
-import { schnorr } from '@noble/curves/secp256k1'
-import { bytesToHex } from '@noble/hashes/utils'
-
-export function generatePrivateKey(): string {
-  return bytesToHex(schnorr.utils.randomPrivateKey())
-}
-
-export function getPublicKey(privateKey: string): string {
-  return bytesToHex(schnorr.getPublicKey(privateKey))
-}

kinds.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { classifyKind } from './kinds.ts'
 
 test('kind classification', () => {

kinds.ts

@@ -1,28 +1,28 @@
 /** Events are **regular**, which means they're all expected to be stored by relays. */
-function isRegularKind(kind: number) {
+export function isRegularKind(kind: number) {
   return (1000 <= kind && kind < 10000) || [1, 2, 4, 5, 6, 7, 8, 16, 40, 41, 42, 43, 44].includes(kind)
 }
 
 /** Events are **replaceable**, which means that, for each combination of `pubkey` and `kind`, only the latest event is expected to (SHOULD) be stored by relays, older versions are expected to be discarded. */
-function isReplaceableKind(kind: number) {
-  return (10000 <= kind && kind < 20000) || [0, 3].includes(kind)
+export function isReplaceableKind(kind: number) {
+  return [0, 3].includes(kind) || (10000 <= kind && kind < 20000)
 }
 
 /** Events are **ephemeral**, which means they are not expected to be stored by relays. */
-function isEphemeralKind(kind: number) {
+export function isEphemeralKind(kind: number) {
   return 20000 <= kind && kind < 30000
 }
 
 /** Events are **parameterized replaceable**, which means that, for each combination of `pubkey`, `kind` and the `d` tag, only the latest event is expected to be stored by relays, older versions are expected to be discarded. */
-function isParameterizedReplaceableKind(kind: number) {
+export function isParameterizedReplaceableKind(kind: number) {
   return 30000 <= kind && kind < 40000
 }
 
 /** Classification of the event kind. */
-type KindClassification = 'regular' | 'replaceable' | 'ephemeral' | 'parameterized' | 'unknown'
+export type KindClassification = 'regular' | 'replaceable' | 'ephemeral' | 'parameterized' | 'unknown'
 
 /** Determine the classification of this kind of event if known, or `unknown`. */
-function classifyKind(kind: number): KindClassification {
+export function classifyKind(kind: number): KindClassification {
   if (isRegularKind(kind)) return 'regular'
   if (isReplaceableKind(kind)) return 'replaceable'
   if (isEphemeralKind(kind)) return 'ephemeral'
@@ -30,11 +30,76 @@ function classifyKind(kind: number): KindClassification {
   return 'unknown'
 }
 
-export {
-  classifyKind,
-  isEphemeralKind,
-  isParameterizedReplaceableKind,
-  isRegularKind,
-  isReplaceableKind,
-  type KindClassification,
-}
+export const Metadata = 0
+export const ShortTextNote = 1
+export const RecommendRelay = 2
+export const Contacts = 3
+export const EncryptedDirectMessage = 4
+export const EventDeletion = 5
+export const Repost = 6
+export const Reaction = 7
+export const BadgeAward = 8
+export const ChannelCreation = 40
+export const ChannelMetadata = 41
+export const ChannelMessage = 42
+export const ChannelHideMessage = 43
+export const ChannelMuteUser = 44
+export const Report = 1984
+export const ZapRequest = 9734
+export const Zap = 9735
+export const RelayList = 10002
+export const ClientAuth = 22242
+export const BadgeDefinition = 30009
+export const FileMetadata = 1063
+export const EncryptedDirectMessages = 4
+export const GenericRepost = 16
+export const OpenTimestamps = 1040
+export const LiveChatMessage = 1311
+export const ProblemTracker = 1971
+export const Reporting = 1984
+export const Label = 1985
+export const CommunityPostApproval = 4550
+export const JobRequest = 5999
+export const JobResult = 6999
+export const JobFeedback = 7000
+export const ZapGoal = 9041
+export const Highlights = 9802
+export const Mutelist = 10000
+export const Pinlist = 10001
+export const BookmarkList = 10003
+export const CommunitiesList = 10004
+export const PublicChatsList = 10005
+export const BlockedRelaysList = 10006
+export const SearchRelaysList = 10007
+export const InterestsList = 10015
+export const UserEmojiList = 10030
+export const NWCWalletInfo = 13194
+export const LightningPubRPC = 21000
+export const NWCWalletRequest = 23194
+export const NWCWalletResponse = 23195
+export const NostrConnect = 24133
+export const HTTPAuth = 27235
+export const Followsets = 30000
+export const Genericlists = 30001
+export const Relaysets = 30002
+export const Bookmarksets = 30003
+export const Curationsets = 30004
+export const ProfileBadges = 30008
+export const Interestsets = 30015
+export const CreateOrUpdateStall = 30017
+export const CreateOrUpdateProduct = 30018
+export const LongFormArticle = 30023
+export const DraftLong = 30024
+export const Emojisets = 30030
+export const Application = 30078
+export const LiveEvent = 30311
+export const UserStatuses = 30315
+export const ClassifiedListing = 30402
+export const DraftClassifiedListing = 30403
+export const Date = 31922
+export const Time = 31923
+export const Calendar = 31924
+export const CalendarEventRSVP = 31925
+export const Handlerrecommendation = 31989
+export const Handlerinformation = 31990
+export const CommunityDefinition = 34550

nip04.test.ts

@@ -1,17 +1,50 @@
+import { test, expect } from 'bun:test'
 import crypto from 'node:crypto'
 
 import { encrypt, decrypt } from './nip04.ts'
-import { getPublicKey, generatePrivateKey } from './keys.ts'
+import { getPublicKey, generateSecretKey } from './pure.ts'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
 
-// @ts-ignore
-// eslint-disable-next-line no-undef
-globalThis.crypto = crypto
+try {
+  // @ts-ignore
+  // eslint-disable-next-line no-undef
+  globalThis.crypto = crypto
+} catch (err) {
+  /***/
+}
 
 test('encrypt and decrypt message', async () => {
-  let sk1 = generatePrivateKey()
-  let sk2 = generatePrivateKey()
+  let sk1 = generateSecretKey()
+  let sk2 = generateSecretKey()
   let pk1 = getPublicKey(sk1)
   let pk2 = getPublicKey(sk2)
 
-  expect(await decrypt(sk2, pk1, await encrypt(sk1, pk2, 'hello'))).toEqual('hello')
+  let ciphertext = await encrypt(bytesToHex(sk1), pk2, 'hello')
+
+  expect(await decrypt(bytesToHex(sk2), pk1, ciphertext)).toEqual('hello')
+})
+
+test('decrypt message from go-nostr', async () => {
+  let sk1 = '91ba716fa9e7ea2fcbad360cf4f8e0d312f73984da63d90f524ad61a6a1e7dbe'
+  let sk2 = '96f6fa197aa07477ab88f6981118466ae3a982faab8ad5db9d5426870c73d220'
+  let pk1 = getPublicKey(hexToBytes(sk1))
+
+  let ciphertext = 'zJxfaJ32rN5Dg1ODjOlEew==?iv=EV5bUjcc4OX2Km/zPp4ndQ=='
+
+  expect(await decrypt(sk2, pk1, ciphertext)).toEqual('nanana')
+})
+
+test('decrypt big payload from go-nostr', async () => {
+  let sk1 = '91ba716fa9e7ea2fcbad360cf4f8e0d312f73984da63d90f524ad61a6a1e7dbe'
+  let sk2 = '96f6fa197aa07477ab88f6981118466ae3a982faab8ad5db9d5426870c73d220'
+  let pk1 = getPublicKey(hexToBytes(sk1))
+
+  let ciphertext =
+    '6f8dMstm+udOu7yipSn33orTmwQpWbtfuY95NH+eTU1kArysWJIDkYgI2D25EAGIDJsNd45jOJ2NbVOhFiL3ZP/NWsTwXokk34iyHyA/lkjzugQ1bHXoMD1fP/Ay4hB4al1NHb8HXHKZaxPrErwdRDb8qa/I6dXb/1xxyVvNQBHHvmsM5yIFaPwnCN1DZqXf2KbTA/Ekz7Hy+7R+Sy3TXLQDFpWYqykppkXc7Fs0qSuPRyxz5+anuN0dxZa9GTwTEnBrZPbthKkNRrvZMdTGJ6WumOh9aUq8OJJWy9aOgsXvs7qjN1UqcCqQqYaVnEOhCaqWNDsVtsFrVDj+SaLIBvCiomwF4C4nIgngJ5I69tx0UNI0q+ZnvOGQZ7m1PpW2NYP7Yw43HJNdeUEQAmdCPnh/PJwzLTnIxHmQU7n7SPlMdV0SFa6H8y2HHvex697GAkyE5t8c2uO24OnqIwF1tR3blIqXzTSRl0GA6QvrSj2p4UtnWjvF7xT7RiIEyTtgU/AsihTrXyXzWWZaIBJogpgw6erlZqWjCH7sZy/WoGYEiblobOAqMYxax6vRbeuGtoYksr/myX+x9rfLrYuoDRTw4woXOLmMrrj+Mf0TbAgc3SjdkqdsPU1553rlSqIEZXuFgoWmxvVQDtekgTYyS97G81TDSK9nTJT5ilku8NVq2LgtBXGwsNIw/xekcOUzJke3kpnFPutNaexR1VF3ohIuqRKYRGcd8ADJP2lfwMcaGRiplAmFoaVS1YUhQwYFNq9rMLf7YauRGV4BJg/t9srdGxf5RoKCvRo+XM/nLxxysTR9MVaEP/3lDqjwChMxs+eWfLHE5vRWV8hUEqdrWNZV29gsx5nQpzJ4PARGZVu310pQzc6JAlc2XAhhFk6RamkYJnmCSMnb/RblzIATBi2kNrCVAlaXIon188inB62rEpZGPkRIP7PUfu27S/elLQHBHeGDsxOXsBRo1gl3te+raoBHsxo6zvRnYbwdAQa5taDE63eh+fT6kFI+xYmXNAQkU8Dp0MVhEh4JQI06Ni/AKrvYpC95TXXIphZcF+/Pv/vaGkhG2X9S3uhugwWK?iv=2vWkOQQi0WynNJz/aZ4k2g=='
+  let plaintext = ''
+  for (let i = 0; i < 800; i++) {
+    plaintext += 'z'
+  }
+
+  expect(await decrypt(sk2, pk1, ciphertext)).toEqual(plaintext)
 })

nip04.ts

@@ -1,4 +1,4 @@
-import { randomBytes } from '@noble/hashes/utils'
+import { bytesToHex, randomBytes } from '@noble/hashes/utils'
 import { secp256k1 } from '@noble/curves/secp256k1'
 import { base64 } from '@scure/base'
 
@@ -10,7 +10,8 @@ if (typeof crypto !== 'undefined' && !crypto.subtle && crypto.webcrypto) {
   crypto.subtle = crypto.webcrypto.subtle
 }
 
-export async function encrypt(privkey: string, pubkey: string, text: string): Promise<string> {
+export async function encrypt(secretKey: string | Uint8Array, pubkey: string, text: string): Promise<string> {
+  const privkey: string = secretKey instanceof Uint8Array ? bytesToHex(secretKey) : secretKey
   const key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
   const normalizedKey = getNormalizedX(key)
 
@@ -24,7 +25,8 @@ export async function encrypt(privkey: string, pubkey: string, text: string): Pr
   return `${ctb64}?iv=${ivb64}`
 }
 
-export async function decrypt(privkey: string, pubkey: string, data: string): Promise<string> {
+export async function decrypt(secretKey: string | Uint8Array, pubkey: string, data: string): Promise<string> {
+  const privkey: string = secretKey instanceof Uint8Array ? bytesToHex(secretKey) : secretKey
   let [ctb64, ivb64] = data.split('?iv=')
   let key = secp256k1.getSharedSecret(privkey, '02' + pubkey)
   let normalizedKey = getNormalizedX(key)

nip05.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import fetch from 'node-fetch'
 
 import { useFetchImplementation, queryProfile } from './nip05.ts'
@@ -15,12 +16,5 @@ test('fetch nip05 profiles', async () => {
 
   let p3 = await queryProfile('_@fiatjaf.com')
   expect(p3!.pubkey).toEqual('3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d')
-  expect(p3!.relays).toEqual([
-    'wss://relay.nostr.bg',
-    'wss://nos.lol',
-    'wss://nostr-verified.wellorder.net',
-    'wss://nostr.zebedee.cloud',
-    'wss://eden.nostr.land',
-    'wss://nostr.milou.lol',
-  ])
+  expect(p3!.relays).toEqual(['wss://pyramid.fiatjaf.com', 'wss://nos.lol'])
 })

nip06.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { privateKeyFromSeedWords } from './nip06.ts'
 
 test('generate private key from a mnemonic', async () => {
@@ -6,9 +7,22 @@ test('generate private key from a mnemonic', async () => {
   expect(privateKey).toEqual('c26cf31d8ba425b555ca27d00ca71b5008004f2f662470f8c8131822ec129fe2')
 })
 
+test('generate private key for account 1 from a mnemonic', async () => {
+  const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
+  const privateKey = privateKeyFromSeedWords(mnemonic, undefined, 1)
+  expect(privateKey).toEqual('b5fc7f229de3fb5c189063e3b3fc6c921d8f4366cff5bd31c6f063493665eb2b')
+})
+
 test('generate private key from a mnemonic and passphrase', async () => {
   const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
   const passphrase = '123'
   const privateKey = privateKeyFromSeedWords(mnemonic, passphrase)
   expect(privateKey).toEqual('55a22b8203273d0aaf24c22c8fbe99608e70c524b17265641074281c8b978ae4')
 })
+
+test('generate private key for account 1 from a mnemonic and passphrase', async () => {
+  const mnemonic = 'zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong'
+  const passphrase = '123'
+  const privateKey = privateKeyFromSeedWords(mnemonic, passphrase, 1)
+  expect(privateKey).toEqual('2e0f7bd9e3c3ebcdff1a90fb49c913477e7c055eba1a415d571b6a8c714c7135')
+})

nip06.ts

@@ -3,9 +3,9 @@ import { wordlist } from '@scure/bip39/wordlists/english'
 import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'
 import { HDKey } from '@scure/bip32'
 
-export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string): string {
+export function privateKeyFromSeedWords(mnemonic: string, passphrase?: string, accountIndex = 0): string {
   let root = HDKey.fromMasterSeed(mnemonicToSeedSync(mnemonic, passphrase))
-  let privateKey = root.derive(`m/44'/1237'/0'/0/0`).privateKey
+  let privateKey = root.derive(`m/44'/1237'/${accountIndex}'/0/0`).privateKey
   if (!privateKey) throw new Error('could not derive private key')
   return bytesToHex(privateKey)
 }

nip10.test.ts

@@ -1,3 +1,4 @@
+import { describe, test, expect } from 'bun:test'
 import { parse } from './nip10.ts'
 
 describe('parse NIP10-referenced events', () => {
@@ -171,10 +172,6 @@ describe('parse NIP10-referenced events', () => {
     })
   })
 
-  test.todo('recommended + a lot of events')
-  test.todo('recommended + 3 events')
-  test.todo('recommended + 2 events')
-
   test('recommended + 1 event', () => {
     let event = {
       tags: [

nip10.ts

@@ -1,4 +1,4 @@
-import type { Event } from './event.ts'
+import type { Event } from './pure.ts'
 import type { EventPointer, ProfilePointer } from './nip19.ts'
 
 export type NIP10Result = {

nip11.test.ts

@@ -0,0 +1,16 @@
+import { describe, test, expect } from 'bun:test'
+import fetch from 'node-fetch'
+import { useFetchImplementation, fetchRelayInformation } from './nip11'
+
+describe('requesting relay as for NIP11', () => {
+  useFetchImplementation(fetch)
+
+  test('testing a relay', async () => {
+    const info = await fetchRelayInformation('wss://atlas.nostr.land')
+    expect(info.name).toEqual('nostr.land')
+    expect(info.description).toEqual('nostr.land family of relays (us-or-01)')
+    expect(info.fees).toBeTruthy()
+    expect(info.supported_nips).toEqual([1, 2, 4, 9, 11, 12, 16, 20, 22, 28, 33, 40])
+    expect(info.software).toEqual('custom')
+  })
+})

nip11.ts

@@ -0,0 +1,286 @@
+var _fetch: any
+
+try {
+  _fetch = fetch
+} catch {}
+
+export function useFetchImplementation(fetchImplementation: any) {
+  _fetch = fetchImplementation
+}
+
+export async function fetchRelayInformation(url: string) {
+  return (await (
+    await fetch(url.replace('ws://', 'http://').replace('wss://', 'https://'), {
+      headers: { Accept: 'application/nostr+json' },
+    })
+  ).json()) as RelayInformation
+}
+
+/**
+ * ## Relay Information Document
+
+ * Relays may provide server metadata to clients to inform
+ * them of capabilities, administrative contacts, and
+ * various server attributes. This is made available as a
+ * JSON document over HTTP, on the same URI as the relay's
+ * websocket.
+
+ * Any field may be omitted, and clients MUST ignore any
+ * additional fields they do not understand. Relays MUST
+ * accept CORS requests by sending
+ * `Access-Control-Allow-Origin`,
+ * `Access-Control-Allow-Headers`, and
+ * `Access-Control-Allow-Methods` headers.
+ * @param name string identifying relay
+ * @param description string with detailed information
+ * @param pubkey administrative contact pubkey
+ * @param contact: administrative alternate contact
+ * @param supported_nips a list of NIP numbers supported by
+ * the relay
+ * @param software identifying relay software URL
+ * @param version string version identifier
+ */
+export interface BasicRelayInformation {
+  // string identifying relay
+  name: string
+  description: string
+  pubkey: string
+  contact: string
+  supported_nips: number[]
+  software: string
+  version: string
+  // limitation?: Limitations<A, P>
+}
+
+/**
+ *  * ## Extra Fields
+
+ *  * ### Server Limitations
+
+ * These are limitations imposed by the relay on clients.
+ * Your client should expect that requests which exceed
+ * these practical_ limitations are rejected or fail immediately.
+ * @param max_message_length this is the maximum number of
+ * bytes for incoming JSON that the relay will attempt to
+ * decode and act upon. When you send large subscriptions,
+ * you will be limited by this value. It also effectively
+ * limits the maximum size of any event. Value is calculated
+ * from `[` to `]` and is after UTF-8 serialization (so some
+ * unicode characters will cost 2-3 bytes). It is equal to
+ * the maximum size of the WebSocket message frame.
+ * @param max_subscription total number of subscriptions
+ * that may be active on a single websocket connection to
+ * this relay. It's possible that authenticated clients with
+ * a (paid) relationship to the relay may have higher limits.
+ * @param max_filters maximum number of filter values in
+ * each subscription. Must be one or higher.
+ * @param max_limit the relay server will clamp each
+ * filter's `limit` value to this number.
+ * This means the client won't be able to get more than this
+ * number of events from a single subscription filter. This
+ * clamping is typically done silently by the relay, but
+ * with this number, you can know that there are additional
+ * results if you narrowed your filter's time range or other
+ * parameters.
+ * @param max_subid_length maximum length of subscription id as a
+ * string.
+ * @param min_prefix for `authors` and `ids` filters which
+ * are to match against a hex prefix, you must provide at
+ * least this many hex digits in the prefix.
+ * @param max_event_tags in any event, this is the maximum
+ * number of elements in the `tags` list.
+ * @param max_content_length maximum number of characters in
+ * the `content` field of any event. This is a count of
+ * unicode characters. After serializing into JSON it may be
+ * larger (in bytes), and is still subject to the
+ * max_message_length`, if defined.
+ * @param min_pow_difficulty new events will require at
+ * least this difficulty of PoW, based on [NIP-13](13.md),
+ * or they will be rejected by this server.
+ * @param auth_required this relay requires [NIP-42](42.md)
+ * authentication to happen before a new connection may
+ * perform any other action. Even if set to False,
+ * authentication may be required for specific actions.
+ * @param payment_required this relay requires payment
+ * before a new connection may perform any action.
+ */
+export interface Limitations {
+  max_message_length: number
+  max_subscription: number
+  max_filters: number
+  max_limit: number
+  max_subid_length: number
+  min_prefix: number
+  max_event_tags: number
+  max_content_length: number
+  min_pow_difficulty: number
+  auth_required: boolean
+  payment_required: boolean
+}
+
+interface RetentionDetails {
+  kinds: (number | number[])[]
+  time?: number | null
+  count?: number | null
+}
+type AnyRetentionDetails = RetentionDetails
+/**
+ * ### Event Retention
+
+ * There may be a cost associated with storing data forever,
+ * so relays may wish to state retention times. The values
+ * stated here are defaults for unauthenticated users and
+ * visitors. Paid users would likely have other policies.
+
+ * Retention times are given in seconds, with `null`
+ * indicating infinity. If zero is provided, this means the
+ * event will not be stored at all, and preferably an error
+ * will be provided when those are received.
+ * ```json
+{
+...
+  "retention": [
+    { "kinds": [0, 1, [5, 7], [40, 49]], "time": 3600 },
+    { "kinds": [[40000, 49999]], "time": 100 },
+    { "kinds": [[30000, 39999]], "count": 1000 },
+    { "time": 3600, "count": 10000 }
+  ]
+...
+}
+```
+ * @param retention is a list of specifications: each will
+ * apply to either all kinds, or a subset of kinds. Ranges
+ * may be specified for the kind field as a tuple of
+ * inclusive start and end values. Events of indicated kind
+ * (or all) are then limited to a `count` and/or time
+ * period.
+
+ * It is possible to effectively blacklist Nostr-based
+ * protocols that rely on a specific `kind` number, by
+ * giving a retention time of zero for those `kind` values.
+ * While that is unfortunate, it does allow clients to
+ * discover servers that will support their protocol quickly
+ * via a single HTTP fetch.
+
+ * There is no need to specify retention times for
+ * _ephemeral events_ as defined in [NIP-16](16.md) since
+ * they are not retained.
+ */
+export interface Retention {
+  retention: AnyRetentionDetails[]
+}
+
+/**
+ * Some relays may be governed by the arbitrary laws of a
+ * nation state. This may limit what content can be stored
+ * in cleartext on those relays. All clients are encouraged
+ * to use encryption to work around this limitation.
+
+ * It is not possible to describe the limitations of each
+ * country's laws and policies which themselves are
+ * typically vague and constantly shifting.
+
+ * Therefore, this field allows the relay operator to
+ * indicate which countries' laws might end up being
+ * enforced on them, and then indirectly on their users'
+ * content.
+
+ * Users should be able to avoid relays in countries they
+ * don't like, and/or select relays in more favourable
+ * zones. Exposing this flexibility is up to the client
+ * software.
+
+ * @param relay_countries a list of two-level ISO country
+ * codes (ISO 3166-1 alpha-2) whose laws and policies may
+ * affect this relay. `EU` may be used for European Union
+ * countries.
+
+ * Remember that a relay may be hosted in a country which is
+ * not the country of the legal entities who own the relay,
+ * so it's very likely a number of countries are involved.
+ */
+export interface ContentLimitations {
+  relay_countries: string[]
+}
+
+/**
+ * ### Community Preferences
+
+ * For public text notes at least, a relay may try to foster
+ * a local community. This would encourage users to follow
+ * the global feed on that relay, in addition to their usual
+ * individual follows. To support this goal, relays MAY
+ * specify some of the following values.
+
+ * @param language_tags  is an ordered list of [IETF
+ * language
+ * tags](https://en.wikipedia.org/wiki/IETF_language_tag
+ * indicating the major languages spoken on the relay.
+ * @param tags is a list of limitations on the topics to be
+ * discussed. For example `sfw-only` indicates that only
+ * "Safe For Work" content is encouraged on this relay. This
+ * relies on assumptions of what the "work" "community"
+ * feels "safe" talking about. In time, a common set of tags
+ * may emerge that allow users to find relays that suit
+ * their needs, and client software will be able to parse
+ * these tags easily. The `bitcoin-only` tag indicates that
+ * any _altcoin_, _"crypto"_ or _blockchain_ comments will
+ * be ridiculed without mercy.
+ * @param posting_policy is a link to a human-readable page
+ * which specifies the community policies for the relay. In
+ * cases where `sfw-only` is True, it's important to link to
+ * a page which gets into the specifics of your posting
+ * policy.
+
+ * The `description` field should be used to describe your
+ * community goals and values, in brief. The
+ * `posting_policy` is for additional detail and legal
+ * terms. Use the `tags` field to signify limitations on
+ * content, or topics to be discussed, which could be
+ * machine processed by appropriate client software.
+ */
+export interface CommunityPreferences {
+  language_tags: string[]
+  tags: string[]
+  posting_policy: string
+}
+
+export interface Amount {
+  amount: number
+  unit: 'msat'
+}
+export interface PublicationAmount extends Amount {
+  kinds: number[]
+}
+export interface Subscription extends Amount {
+  period: number
+}
+export interface Fees {
+  admission: Amount[]
+  subscription: Subscription[]
+  publication: PublicationAmount[]
+}
+/**
+ * Relays that require payments may want to expose their fee
+ * schedules.
+ */
+export interface PayToRelay {
+  payments_url: string
+  fees: Fees
+}
+
+/**
+ * A URL pointing to an image to be used as an icon for the
+ * relay. Recommended to be squared in shape.
+ */
+export interface Icon {
+  icon: string
+}
+
+export type RelayInformation = BasicRelayInformation &
+  Partial<Retention> & {
+    limitation?: Partial<Limitations>
+  } & Partial<ContentLimitations> &
+  Partial<CommunityPreferences> &
+  Partial<PayToRelay> &
+  Partial<Icon>

nip13.test.ts

@@ -1,5 +1,5 @@
+import { test, expect } from 'bun:test'
 import { getPow, minePow } from './nip13.ts'
-import { Kind } from './event.ts'
 
 test('identifies proof-of-work difficulty', async () => {
   const id = '000006d8c378af1779d2feebc7603a125d99eca0ccf1085959b307f64e5dd358'
@@ -12,7 +12,7 @@ test('mines POW for an event', async () => {
 
   const event = minePow(
     {
-      kind: Kind.Text,
+      kind: 1,
       tags: [],
       content: 'Hello, world!',
       created_at: 0,

nip13.ts

@@ -1,4 +1,4 @@
-import { type UnsignedEvent, type Event, getEventHash } from './event.ts'
+import { type UnsignedEvent, type Event, getEventHash } from './pure.ts'
 
 /** Get POW difficulty from a Nostr hex ID. */
 export function getPow(hex: string): number {
@@ -23,10 +23,10 @@ export function getPow(hex: string): number {
  *
  * Adapted from Snort: https://git.v0l.io/Kieran/snort/src/commit/4df6c19248184218c4c03728d61e94dae5f2d90c/packages/system/src/pow-util.ts#L14-L36
  */
-export function minePow<K extends number>(unsigned: UnsignedEvent<K>, difficulty: number): Omit<Event<K>, 'sig'> {
+export function minePow(unsigned: UnsignedEvent, difficulty: number): Omit<Event, 'sig'> {
   let count = 0
 
-  const event = unsigned as Omit<Event<K>, 'sig'>
+  const event = unsigned as Omit<Event, 'sig'>
   const tag = ['nonce', count.toString(), difficulty.toString()]
 
   event.tags.push(tag)

nip18.test.ts

@@ -1,18 +1,19 @@
-import { finishEvent, Kind } from './event.ts'
-import { getPublicKey } from './keys.ts'
+import { describe, test, expect } from 'bun:test'
+import { hexToBytes } from '@noble/hashes/utils'
+import { finalizeEvent, getPublicKey } from './pure.ts'
+import { Repost, ShortTextNote } from './kinds.ts'
 import { finishRepostEvent, getRepostedEventPointer, getRepostedEvent } from './nip18.ts'
 import { buildEvent } from './test-helpers.ts'
 
 const relayUrl = 'https://relay.example.com'
 
 describe('finishRepostEvent + getRepostedEventPointer + getRepostedEvent', () => {
-  const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
+  const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
   const publicKey = getPublicKey(privateKey)
 
-  const repostedEvent = finishEvent(
+  const repostedEvent = finalizeEvent(
     {
-      kind: Kind.Text,
+      kind: ShortTextNote,
       tags: [
         ['e', 'replied event id'],
         ['p', 'replied event pubkey'],
@@ -23,14 +24,14 @@ describe('finishRepostEvent + getRepostedEventPointer + getRepostedEvent', () =>
     privateKey,
   )
 
-  it('should create a signed event from a minimal template', () => {
+  test('should create a signed event from a minimal template', () => {
     const template = {
       created_at: 1617932115,
     }
 
     const event = finishRepostEvent(template, repostedEvent, relayUrl, privateKey)
 
-    expect(event.kind).toEqual(Kind.Repost)
+    expect(event.kind).toEqual(Repost)
     expect(event.tags).toEqual([
       ['e', repostedEvent.id, relayUrl],
       ['p', repostedEvent.pubkey],
@@ -52,7 +53,7 @@ describe('finishRepostEvent + getRepostedEventPointer + getRepostedEvent', () =>
     expect(repostedEventFromContent).toEqual(repostedEvent)
   })
 
-  it('should create a signed event from a filled template', () => {
+  test('should create a signed event from a filled template', () => {
     const template = {
       tags: [['nonstandard', 'tag']],
       content: '' as const,
@@ -61,7 +62,7 @@ describe('finishRepostEvent + getRepostedEventPointer + getRepostedEvent', () =>
 
     const event = finishRepostEvent(template, repostedEvent, relayUrl, privateKey)
 
-    expect(event.kind).toEqual(Kind.Repost)
+    expect(event.kind).toEqual(Repost)
     expect(event.tags).toEqual([
       ['nonstandard', 'tag'],
       ['e', repostedEvent.id, relayUrl],
@@ -81,21 +82,21 @@ describe('finishRepostEvent + getRepostedEventPointer + getRepostedEvent', () =>
 
     const repostedEventFromContent = getRepostedEvent(event)
 
-    expect(repostedEventFromContent).toEqual(undefined)
+    expect(repostedEventFromContent).toBeUndefined()
   })
 })
 
 describe('getRepostedEventPointer', () => {
-  it('should parse an event with only an `e` tag', () => {
+  test('should parse an event with only an `e` tag', () => {
     const event = buildEvent({
-      kind: Kind.Repost,
+      kind: Repost,
       tags: [['e', 'reposted event id', relayUrl]],
     })
 
     const repostedEventPointer = getRepostedEventPointer(event)
 
     expect(repostedEventPointer!.id).toEqual('reposted event id')
-    expect(repostedEventPointer!.author).toEqual(undefined)
+    expect(repostedEventPointer!.author).toBeUndefined()
     expect(repostedEventPointer!.relays).toEqual([relayUrl])
   })
 })

nip18.ts

@@ -1,4 +1,5 @@
-import { Event, finishEvent, Kind, verifySignature } from './event.ts'
+import { Event, finalizeEvent, verifyEvent } from './pure.ts'
+import { Repost } from './kinds.ts'
 import { EventPointer } from './nip19.ts'
 
 export type RepostEventTemplate = {
@@ -20,13 +21,13 @@ export type RepostEventTemplate = {
 
 export function finishRepostEvent(
   t: RepostEventTemplate,
-  reposted: Event<number>,
+  reposted: Event,
   relayUrl: string,
-  privateKey: string,
+  privateKey: Uint8Array,
 ): Event {
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.Repost,
+      kind: Repost,
       tags: [...(t.tags ?? []), ['e', reposted.id, relayUrl], ['p', reposted.pubkey]],
       content: t.content === '' ? '' : JSON.stringify(reposted),
       created_at: t.created_at,
@@ -35,8 +36,8 @@ export function finishRepostEvent(
   )
 }
 
-export function getRepostedEventPointer(event: Event<number>): undefined | EventPointer {
-  if (event.kind !== Kind.Repost) {
+export function getRepostedEventPointer(event: Event): undefined | EventPointer {
+  if (event.kind !== Repost) {
     return undefined
   }
 
@@ -69,20 +70,17 @@ export type GetRepostedEventOptions = {
   skipVerification?: boolean
 }
 
-export function getRepostedEvent(
-  event: Event<number>,
-  { skipVerification }: GetRepostedEventOptions = {},
-): undefined | Event<number> {
+export function getRepostedEvent(event: Event, { skipVerification }: GetRepostedEventOptions = {}): undefined | Event {
   const pointer = getRepostedEventPointer(event)
 
   if (pointer === undefined || event.content === '') {
     return undefined
   }
 
-  let repostedEvent: undefined | Event<number>
+  let repostedEvent: undefined | Event
 
   try {
-    repostedEvent = JSON.parse(event.content) as Event<number>
+    repostedEvent = JSON.parse(event.content) as Event
   } catch (error) {
     return undefined
   }
@@ -91,7 +89,7 @@ export function getRepostedEvent(
     return undefined
   }
 
-  if (!skipVerification && !verifySignature(repostedEvent)) {
+  if (!skipVerification && !verifyEvent(repostedEvent)) {
     return undefined
   }
 

nip19.test.ts

@@ -1,4 +1,5 @@
-import { generatePrivateKey, getPublicKey } from './keys.ts'
+import { test, expect } from 'bun:test'
+import { generateSecretKey, getPublicKey } from './pure.ts'
 import {
   decode,
   naddrEncode,
@@ -13,7 +14,7 @@ import {
 } from './nip19.ts'
 
 test('encode and decode nsec', () => {
-  let sk = generatePrivateKey()
+  let sk = generateSecretKey()
   let nsec = nsecEncode(sk)
   expect(nsec).toMatch(/nsec1\w+/)
   let { type, data } = decode(nsec)
@@ -22,7 +23,7 @@ test('encode and decode nsec', () => {
 })
 
 test('encode and decode npub', () => {
-  let pk = getPublicKey(generatePrivateKey())
+  let pk = getPublicKey(generateSecretKey())
   let npub = npubEncode(pk)
   expect(npub).toMatch(/npub1\w+/)
   let { type, data } = decode(npub)
@@ -31,7 +32,7 @@ test('encode and decode npub', () => {
 })
 
 test('encode and decode nprofile', () => {
-  let pk = getPublicKey(generatePrivateKey())
+  let pk = getPublicKey(generateSecretKey())
   let relays = ['wss://relay.nostr.example.mydomain.example.com', 'wss://nostr.banana.com']
   let nprofile = nprofileEncode({ pubkey: pk, relays })
   expect(nprofile).toMatch(/nprofile1\w+/)
@@ -55,7 +56,7 @@ test('decode nprofile without relays', () => {
 })
 
 test('encode and decode naddr', () => {
-  let pk = getPublicKey(generatePrivateKey())
+  let pk = getPublicKey(generateSecretKey())
   let relays = ['wss://relay.nostr.example.mydomain.example.com', 'wss://nostr.banana.com']
   let naddr = naddrEncode({
     pubkey: pk,
@@ -75,7 +76,7 @@ test('encode and decode naddr', () => {
 })
 
 test('encode and decode nevent', () => {
-  let pk = getPublicKey(generatePrivateKey())
+  let pk = getPublicKey(generateSecretKey())
   let relays = ['wss://relay.nostr.example.mydomain.example.com', 'wss://nostr.banana.com']
   let naddr = neventEncode({
     id: pk,
@@ -92,7 +93,7 @@ test('encode and decode nevent', () => {
 })
 
 test('encode and decode nevent with kind 0', () => {
-  let pk = getPublicKey(generatePrivateKey())
+  let pk = getPublicKey(generateSecretKey())
   let relays = ['wss://relay.nostr.example.mydomain.example.com', 'wss://nostr.banana.com']
   let naddr = neventEncode({
     id: pk,

nip19.ts

@@ -48,7 +48,7 @@ type Prefixes = {
   nrelay: string
   nevent: EventPointer
   naddr: AddressPointer
-  nsec: string
+  nsec: Uint8Array
   npub: string
   note: string
 }
@@ -130,6 +130,8 @@ export function decode(nip19: string): DecodeResult {
     }
 
     case 'nsec':
+      return { type: prefix, data }
+
     case 'npub':
     case 'note':
       return { type: prefix, data: bytesToHex(data) }
@@ -157,16 +159,16 @@ function parseTLV(data: Uint8Array): TLV {
   return result
 }
 
-export function nsecEncode(hex: string): `nsec1${string}` {
-  return encodeBytes('nsec', hex)
+export function nsecEncode(key: Uint8Array): `nsec1${string}` {
+  return encodeBytes('nsec', key)
 }
 
 export function npubEncode(hex: string): `npub1${string}` {
-  return encodeBytes('npub', hex)
+  return encodeBytes('npub', hexToBytes(hex))
 }
 
 export function noteEncode(hex: string): `note1${string}` {
-  return encodeBytes('note', hex)
+  return encodeBytes('note', hexToBytes(hex))
 }
 
 function encodeBech32<Prefix extends string>(prefix: Prefix, data: Uint8Array): `${Prefix}1${string}` {
@@ -174,9 +176,8 @@ function encodeBech32<Prefix extends string>(prefix: Prefix, data: Uint8Array):
   return bech32.encode(prefix, words, Bech32MaxSize) as `${Prefix}1${string}`
 }
 
-function encodeBytes<Prefix extends string>(prefix: Prefix, hex: string): `${Prefix}1${string}` {
-  let data = hexToBytes(hex)
-  return encodeBech32(prefix, data)
+function encodeBytes<Prefix extends string>(prefix: Prefix, bytes: Uint8Array): `${Prefix}1${string}` {
+  return encodeBech32(prefix, bytes)
 }
 
 export function nprofileEncode(profile: ProfilePointer): `nprofile1${string}` {
@@ -189,7 +190,7 @@ export function nprofileEncode(profile: ProfilePointer): `nprofile1${string}` {
 
 export function neventEncode(event: EventPointer): `nevent1${string}` {
   let kindArray
-  if (event.kind != undefined) {
+  if (event.kind !== undefined) {
     kindArray = integerToUint8Array(event.kind)
   }
 

nip21.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { test as testRegex, parse } from './nip21.ts'
 
 test('test()', () => {

nip25.test.ts

@@ -1,15 +1,16 @@
-import { finishEvent, Kind } from './event.ts'
-import { getPublicKey } from './keys.ts'
+import { describe, test, expect } from 'bun:test'
+import { hexToBytes } from '@noble/hashes/utils'
+import { finalizeEvent, getPublicKey } from './pure.ts'
+import { Reaction, ShortTextNote } from './kinds.ts'
 import { finishReactionEvent, getReactedEventPointer } from './nip25.ts'
 
 describe('finishReactionEvent + getReactedEventPointer', () => {
-  const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
-
+  const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
   const publicKey = getPublicKey(privateKey)
 
-  const reactedEvent = finishEvent(
+  const reactedEvent = finalizeEvent(
     {
-      kind: Kind.Text,
+      kind: ShortTextNote,
       tags: [
         ['e', 'replied event id'],
         ['p', 'replied event pubkey'],
@@ -20,14 +21,14 @@ describe('finishReactionEvent + getReactedEventPointer', () => {
     privateKey,
   )
 
-  it('should create a signed event from a minimal template', () => {
+  test('should create a signed event from a minimal template', () => {
     const template = {
       created_at: 1617932115,
     }
 
     const event = finishReactionEvent(template, reactedEvent, privateKey)
 
-    expect(event.kind).toEqual(Kind.Reaction)
+    expect(event.kind).toEqual(Reaction)
     expect(event.tags).toEqual([
       ['e', 'replied event id'],
       ['p', 'replied event pubkey'],
@@ -46,7 +47,7 @@ describe('finishReactionEvent + getReactedEventPointer', () => {
     expect(reactedEventPointer!.author).toEqual(reactedEvent.pubkey)
   })
 
-  it('should create a signed event from a filled template', () => {
+  test('should create a signed event from a filled template', () => {
     const template = {
       tags: [['nonstandard', 'tag']],
       content: '👍',
@@ -55,7 +56,7 @@ describe('finishReactionEvent + getReactedEventPointer', () => {
 
     const event = finishReactionEvent(template, reactedEvent, privateKey)
 
-    expect(event.kind).toEqual(Kind.Reaction)
+    expect(event.kind).toEqual(Reaction)
     expect(event.tags).toEqual([
       ['nonstandard', 'tag'],
       ['e', 'replied event id'],

nip25.ts

@@ -1,4 +1,5 @@
-import { Event, finishEvent, Kind } from './event.ts'
+import { Event, finalizeEvent } from './pure.ts'
+import { Reaction } from './kinds.ts'
 
 import type { EventPointer } from './nip19.ts'
 
@@ -16,13 +17,13 @@ export type ReactionEventTemplate = {
   created_at: number
 }
 
-export function finishReactionEvent(t: ReactionEventTemplate, reacted: Event<number>, privateKey: string): Event {
+export function finishReactionEvent(t: ReactionEventTemplate, reacted: Event, privateKey: Uint8Array): Event {
   const inheritedTags = reacted.tags.filter(tag => tag.length >= 2 && (tag[0] === 'e' || tag[0] === 'p'))
 
-  return finishEvent(
+  return finalizeEvent(
     {
       ...t,
-      kind: Kind.Reaction,
+      kind: Reaction,
       tags: [...(t.tags ?? []), ...inheritedTags, ['e', reacted.id], ['p', reacted.pubkey]],
       content: t.content ?? '+',
     },
@@ -30,8 +31,8 @@ export function finishReactionEvent(t: ReactionEventTemplate, reacted: Event<num
   )
 }
 
-export function getReactedEventPointer(event: Event<number>): undefined | EventPointer {
-  if (event.kind !== Kind.Reaction) {
+export function getReactedEventPointer(event: Event): undefined | EventPointer {
+  if (event.kind !== Reaction) {
     return undefined
   }
 

nip26.test.ts

@@ -1,101 +0,0 @@
-import { getPublicKey, generatePrivateKey } from './keys.ts'
-import { getDelegator, createDelegation } from './nip26.ts'
-import { buildEvent } from './test-helpers.ts'
-
-test('parse good delegation from NIP', async () => {
-  expect(
-    getDelegator({
-      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
-      pubkey: '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
-      created_at: 1660896109,
-      kind: 1,
-      tags: [
-        [
-          'delegation',
-          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
-          'kind=1&created_at>1640995200',
-          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1',
-        ],
-      ],
-      content: 'Hello world',
-      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6',
-    }),
-  ).toEqual('86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e')
-})
-
-test('parse bad delegations', async () => {
-  expect(
-    getDelegator({
-      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
-      pubkey: '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
-      created_at: 1660896109,
-      kind: 1,
-      tags: [
-        [
-          'delegation',
-          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42f',
-          'kind=1&created_at>1640995200',
-          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1',
-        ],
-      ],
-      content: 'Hello world',
-      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6',
-    }),
-  ).toEqual(null)
-
-  expect(
-    getDelegator({
-      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
-      pubkey: '62903b1ff41559daf9ee98ef1ae67cc52f301bb5ce26d14baba3052f649c3f49',
-      created_at: 1660896109,
-      kind: 1,
-      tags: [
-        [
-          'delegation',
-          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
-          'kind=1&created_at>1740995200',
-          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1',
-        ],
-      ],
-      content: 'Hello world',
-      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6',
-    }),
-  ).toEqual(null)
-
-  expect(
-    getDelegator({
-      id: 'a080fd288b60ac2225ff2e2d815291bd730911e583e177302cc949a15dc2b2dc',
-      pubkey: '62903b1ff41559daf9ee98ef1ae67c152f301bb5ce26d14baba3052f649c3f49',
-      created_at: 1660896109,
-      kind: 1,
-      tags: [
-        [
-          'delegation',
-          '86f0689bd48dcd19c67a19d994f938ee34f251d8c39976290955ff585f2db42e',
-          'kind=1&created_at>1640995200',
-          'c33c88ba78ec3c760e49db591ac5f7b129e3887c8af7729795e85a0588007e5ac89b46549232d8f918eefd73e726cb450135314bfda419c030d0b6affe401ec1',
-        ],
-      ],
-      content: 'Hello world',
-      sig: 'cd4a3cd20dc61dcbc98324de561a07fd23b3d9702115920c0814b5fb822cc5b7c5bcdaf3fa326d24ed50c5b9c8214d66c75bae34e3a84c25e4d122afccb66eb6',
-    }),
-  ).toEqual(null)
-})
-
-test('create and verify delegation', async () => {
-  let sk1 = generatePrivateKey()
-  let pk1 = getPublicKey(sk1)
-  let sk2 = generatePrivateKey()
-  let pk2 = getPublicKey(sk2)
-  let delegation = createDelegation(sk1, { pubkey: pk2, kind: 1 })
-  expect(delegation).toHaveProperty('from', pk1)
-  expect(delegation).toHaveProperty('to', pk2)
-  expect(delegation).toHaveProperty('cond', 'kind=1')
-
-  let event = buildEvent({
-    kind: 1,
-    tags: [['delegation', delegation.from, delegation.cond, delegation.sig]],
-    pubkey: pk2,
-  })
-  expect(getDelegator(event)).toEqual(pk1)
-})

nip26.ts

@@ -1,71 +0,0 @@
-import { schnorr } from '@noble/curves/secp256k1'
-import { bytesToHex } from '@noble/hashes/utils'
-import { sha256 } from '@noble/hashes/sha256'
-
-import { utf8Encoder } from './utils.ts'
-import { getPublicKey } from './keys.ts'
-
-import type { Event } from './event.ts'
-
-export type Parameters = {
-  pubkey: string // the key to whom the delegation will be given
-  kind?: number
-  until?: number // delegation will only be valid until this date
-  since?: number // delegation will be valid from this date on
-}
-
-export type Delegation = {
-  from: string // the pubkey who signed the delegation
-  to: string // the pubkey that is allowed to use the delegation
-  cond: string // the string of conditions as they should be included in the event tag
-  sig: string
-}
-
-export function createDelegation(privateKey: string, parameters: Parameters): Delegation {
-  let conditions = []
-  if ((parameters.kind || -1) >= 0) conditions.push(`kind=${parameters.kind}`)
-  if (parameters.until) conditions.push(`created_at<${parameters.until}`)
-  if (parameters.since) conditions.push(`created_at>${parameters.since}`)
-  let cond = conditions.join('&')
-
-  if (cond === '') throw new Error('refusing to create a delegation without any conditions')
-
-  let sighash = sha256(utf8Encoder.encode(`nostr:delegation:${parameters.pubkey}:${cond}`))
-
-  let sig = bytesToHex(schnorr.sign(sighash, privateKey))
-
-  return {
-    from: getPublicKey(privateKey),
-    to: parameters.pubkey,
-    cond,
-    sig,
-  }
-}
-
-export function getDelegator(event: Event<number>): string | null {
-  // find delegation tag
-  let tag = event.tags.find(tag => tag[0] === 'delegation' && tag.length >= 4)
-  if (!tag) return null
-
-  let pubkey = tag[1]
-  let cond = tag[2]
-  let sig = tag[3]
-
-  // check conditions
-  let conditions = cond.split('&')
-  for (let i = 0; i < conditions.length; i++) {
-    let [key, operator, value] = conditions[i].split(/\b/)
-
-    // the supported conditions are just 'kind' and 'created_at' for now
-    if (key === 'kind' && operator === '=' && event.kind === parseInt(value)) continue
-    else if (key === 'created_at' && operator === '<' && event.created_at < parseInt(value)) continue
-    else if (key === 'created_at' && operator === '>' && event.created_at > parseInt(value)) continue
-    else return null // invalid condition
-  }
-
-  // check signature
-  let sighash = sha256(utf8Encoder.encode(`nostr:delegation:${event.pubkey}:${cond}`))
-  if (!schnorr.verify(sig, sighash, pubkey)) return null
-
-  return pubkey
-}

nip27.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { matchAll, replaceAll } from './nip27.ts'
 
 test('matchAll', () => {

nip28.test.ts

@@ -1,5 +1,7 @@
-import { Kind } from './event.ts'
-import { getPublicKey } from './keys.ts'
+import { describe, test, expect } from 'bun:test'
+import { hexToBytes } from '@noble/hashes/utils'
+import { getPublicKey } from './pure.ts'
+import * as Kind from './kinds.ts'
 import {
   channelCreateEvent,
   channelMetadataEvent,
@@ -10,7 +12,7 @@ import {
   ChannelMessageEventTemplate,
 } from './nip28.ts'
 
-const privateKey = 'd217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf'
+const privateKey = hexToBytes('d217c1ff2f8a65c3e3a1740db3b9f58b8c848bb45e26d00ed4714e4a0f4ceecf')
 const publicKey = getPublicKey(privateKey)
 
 describe('NIP-28 Functions', () => {
@@ -20,7 +22,7 @@ describe('NIP-28 Functions', () => {
     picture: 'https://example.com/picture.jpg',
   }
 
-  it('channelCreateEvent should create an event with given template', () => {
+  test('channelCreateEvent should create an event with given template', () => {
     const template = {
       content: channelMetadata,
       created_at: 1617932115,
@@ -32,7 +34,7 @@ describe('NIP-28 Functions', () => {
     expect(event!.pubkey).toEqual(publicKey)
   })
 
-  it('channelMetadataEvent should create a signed event with given template', () => {
+  test('channelMetadataEvent should create a signed event with given template', () => {
     const template = {
       channel_create_event_id: 'channel creation event id',
       content: channelMetadata,
@@ -48,8 +50,8 @@ describe('NIP-28 Functions', () => {
     expect(typeof event!.sig).toEqual('string')
   })
 
-  it('channelMessageEvent should create a signed message event with given template', () => {
-    const template = {
+  test('channelMessageEvent should create a signed message event with given template', () => {
+    const template: ChannelMessageEventTemplate = {
       channel_create_event_id: 'channel creation event id',
       relay_url: 'https://relay.example.com',
       content: 'Hello, world!',
@@ -65,7 +67,7 @@ describe('NIP-28 Functions', () => {
     expect(typeof event.sig).toEqual('string')
   })
 
-  it('channelMessageEvent should create a signed message reply event with given template', () => {
+  test('channelMessageEvent should create a signed message reply event with given template', () => {
     const template: ChannelMessageEventTemplate = {
       channel_create_event_id: 'channel creation event id',
       reply_to_channel_message_event_id: 'channel message event id',
@@ -76,15 +78,25 @@ describe('NIP-28 Functions', () => {
 
     const event = channelMessageEvent(template, privateKey)
     expect(event.kind).toEqual(Kind.ChannelMessage)
-    expect(event.tags).toContainEqual(['e', template.channel_create_event_id, template.relay_url, 'root'])
-    expect(event.tags).toContainEqual(['e', template.reply_to_channel_message_event_id, template.relay_url, 'reply'])
+    expect(event.tags.find(tag => tag[0] === 'e' && tag[1] === template.channel_create_event_id)).toEqual([
+      'e',
+      template.channel_create_event_id,
+      template.relay_url,
+      'root',
+    ])
+    expect(event.tags.find(tag => tag[0] === 'e' && tag[1] === template.reply_to_channel_message_event_id)).toEqual([
+      'e',
+      template.reply_to_channel_message_event_id as string,
+      template.relay_url,
+      'reply',
+    ])
     expect(event.content).toEqual(template.content)
     expect(event.pubkey).toEqual(publicKey)
     expect(typeof event.id).toEqual('string')
     expect(typeof event.sig).toEqual('string')
   })
 
-  it('channelHideMessageEvent should create a signed event with given template', () => {
+  test('channelHideMessageEvent should create a signed event with given template', () => {
     const template = {
       channel_message_event_id: 'channel message event id',
       content: { reason: 'Inappropriate content' },
@@ -100,7 +112,7 @@ describe('NIP-28 Functions', () => {
     expect(typeof event!.sig).toEqual('string')
   })
 
-  it('channelMuteUserEvent should create a signed event with given template', () => {
+  test('channelMuteUserEvent should create a signed event with given template', () => {
     const template = {
       content: { reason: 'Spamming' },
       created_at: 1617932115,

nip28.ts

@@ -1,4 +1,5 @@
-import { Event, finishEvent, Kind } from './event.ts'
+import { Event, finalizeEvent } from './pure.ts'
+import { ChannelCreation, ChannelHideMessage, ChannelMessage, ChannelMetadata, ChannelMuteUser } from './kinds.ts'
 
 export interface ChannelMetadata {
   name: string
@@ -44,7 +45,7 @@ export interface ChannelMuteUserEventTemplate {
   tags?: string[][]
 }
 
-export const channelCreateEvent = (t: ChannelCreateEventTemplate, privateKey: string): Event | undefined => {
+export const channelCreateEvent = (t: ChannelCreateEventTemplate, privateKey: Uint8Array): Event | undefined => {
   let content: string
   if (typeof t.content === 'object') {
     content = JSON.stringify(t.content)
@@ -54,9 +55,9 @@ export const channelCreateEvent = (t: ChannelCreateEventTemplate, privateKey: st
     return undefined
   }
 
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.ChannelCreation,
+      kind: ChannelCreation,
       tags: [...(t.tags ?? [])],
       content: content,
       created_at: t.created_at,
@@ -65,10 +66,7 @@ export const channelCreateEvent = (t: ChannelCreateEventTemplate, privateKey: st
   )
 }
 
-export const channelMetadataEvent = (
-  t: ChannelMetadataEventTemplate,
-  privateKey: string,
-): Event | undefined => {
+export const channelMetadataEvent = (t: ChannelMetadataEventTemplate, privateKey: Uint8Array): Event | undefined => {
   let content: string
   if (typeof t.content === 'object') {
     content = JSON.stringify(t.content)
@@ -78,9 +76,9 @@ export const channelMetadataEvent = (
     return undefined
   }
 
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.ChannelMetadata,
+      kind: ChannelMetadata,
       tags: [['e', t.channel_create_event_id], ...(t.tags ?? [])],
       content: content,
       created_at: t.created_at,
@@ -89,16 +87,16 @@ export const channelMetadataEvent = (
   )
 }
 
-export const channelMessageEvent = (t: ChannelMessageEventTemplate, privateKey: string): Event => {
+export const channelMessageEvent = (t: ChannelMessageEventTemplate, privateKey: Uint8Array): Event => {
   const tags = [['e', t.channel_create_event_id, t.relay_url, 'root']]
 
   if (t.reply_to_channel_message_event_id) {
     tags.push(['e', t.reply_to_channel_message_event_id, t.relay_url, 'reply'])
   }
 
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.ChannelMessage,
+      kind: ChannelMessage,
       tags: [...tags, ...(t.tags ?? [])],
       content: t.content,
       created_at: t.created_at,
@@ -110,7 +108,7 @@ export const channelMessageEvent = (t: ChannelMessageEventTemplate, privateKey:
 /* "e" tag should be the kind 42 event to hide */
 export const channelHideMessageEvent = (
   t: ChannelHideMessageEventTemplate,
-  privateKey: string,
+  privateKey: Uint8Array,
 ): Event | undefined => {
   let content: string
   if (typeof t.content === 'object') {
@@ -121,9 +119,9 @@ export const channelHideMessageEvent = (
     return undefined
   }
 
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.ChannelHideMessage,
+      kind: ChannelHideMessage,
       tags: [['e', t.channel_message_event_id], ...(t.tags ?? [])],
       content: content,
       created_at: t.created_at,
@@ -132,10 +130,7 @@ export const channelHideMessageEvent = (
   )
 }
 
-export const channelMuteUserEvent = (
-  t: ChannelMuteUserEventTemplate,
-  privateKey: string,
-): Event | undefined => {
+export const channelMuteUserEvent = (t: ChannelMuteUserEventTemplate, privateKey: Uint8Array): Event | undefined => {
   let content: string
   if (typeof t.content === 'object') {
     content = JSON.stringify(t.content)
@@ -145,9 +140,9 @@ export const channelMuteUserEvent = (
     return undefined
   }
 
-  return finishEvent(
+  return finalizeEvent(
     {
-      kind: Kind.ChannelMuteUser,
+      kind: ChannelMuteUser,
       tags: [['p', t.pubkey_to_mute], ...(t.tags ?? [])],
       content: content,
       created_at: t.created_at,

nip30.test.ts

@@ -0,0 +1,33 @@
+import { test, expect } from 'bun:test'
+import { matchAll, replaceAll } from './nip30.ts'
+
+test('matchAll', () => {
+  const result = matchAll('Hello :blobcat: :disputed: ::joy:joy:')
+
+  expect([...result]).toEqual([
+    {
+      name: 'blobcat',
+      shortcode: ':blobcat:',
+      start: 6,
+      end: 15,
+    },
+    {
+      name: 'disputed',
+      shortcode: ':disputed:',
+      start: 16,
+      end: 26,
+    },
+  ])
+})
+
+test('replaceAll', () => {
+  const content = 'Hello :blobcat: :disputed: ::joy:joy:'
+
+  const result = replaceAll(content, ({ name }) => {
+    return `<img src="https://ditto.pub/emoji/${name}.png" />`
+  })
+
+  expect(result).toEqual(
+    'Hello <img src="https://ditto.pub/emoji/blobcat.png" /> <img src="https://ditto.pub/emoji/disputed.png" /> ::joy:joy:',
+  )
+})

nip30.ts

@@ -0,0 +1,51 @@
+/** Regex for a single emoji shortcode. */
+export const EMOJI_SHORTCODE_REGEX = /:(\w+):/
+
+/** Regex to find emoji shortcodes in content. */
+export const regex = () => new RegExp(`\\B${EMOJI_SHORTCODE_REGEX.source}\\B`, 'g')
+
+/** Represents a Nostr custom emoji. */
+export interface CustomEmoji {
+  /** The matched emoji name with colons. */
+  shortcode: `:${string}:`
+  /** The matched emoji name without colons. */
+  name: string
+}
+
+/** Match result for a custom emoji in text content. */
+export interface CustomEmojiMatch extends CustomEmoji {
+  /** Index where the emoji begins in the text content. */
+  start: number
+  /** Index where the emoji ends in the text content. */
+  end: number
+}
+
+/** Find all custom emoji shortcodes. */
+export function* matchAll(content: string): Iterable<CustomEmojiMatch> {
+  const matches = content.matchAll(regex())
+
+  for (const match of matches) {
+    try {
+      const [shortcode, name] = match
+
+      yield {
+        shortcode: shortcode as `:${string}:`,
+        name,
+        start: match.index!,
+        end: match.index! + shortcode.length,
+      }
+    } catch (_e) {
+      // do nothing
+    }
+  }
+}
+
+/** Replace all emoji shortcodes in the content. */
+export function replaceAll(content: string, replacer: (match: CustomEmoji) => string): string {
+  return content.replaceAll(regex(), (shortcode, name) => {
+    return replacer({
+      shortcode: shortcode as `:${string}:`,
+      name,
+    })
+  })
+}

nip39.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import fetch from 'node-fetch'
 
 import { useFetchImplementation, validateGithub } from './nip39.ts'

nip42.test.ts

@@ -1,26 +1,14 @@
-import 'websocket-polyfill'
+import { test, expect } from 'bun:test'
 
-import { finishEvent } from './event.ts'
-import { generatePrivateKey } from './keys.ts'
-import { authenticate } from './nip42.ts'
-import { relayInit } from './relay.ts'
+import { makeAuthEvent } from './nip42.ts'
+import { relayConnect } from './relay.ts'
 
 test('auth flow', () => {
-  const relay = relayInit('wss://nostr.kollider.xyz')
-  relay.connect()
-  const sk = generatePrivateKey()
+  const relay = relayConnect('wss://nostr.wine')
 
-  return new Promise<void>(resolve => {
-    relay.on('auth', async challenge => {
-      await expect(
-        authenticate({
-          challenge,
-          relay,
-          sign: e => finishEvent(e, sk),
-        }),
-      ).rejects.toBeTruthy()
-      relay.close()
-      resolve()
-    })
-  })
+  const auth = makeAuthEvent(relay.url, 'chachacha')
+  expect(auth.tags).toHaveLength(2)
+  expect(auth.tags[0]).toEqual(['relay', 'wss://nostr.wine/'])
+  expect(auth.tags[1]).toEqual(['challenge', 'chachacha'])
+  expect(auth.kind).toEqual(22242)
 })

nip42.ts

@@ -1,32 +1,17 @@
-import { Kind, type EventTemplate, type Event } from './event.ts'
-import { Relay } from './relay.ts'
+import { EventTemplate } from './pure.ts'
+import { ClientAuth } from './kinds.ts'
 
 /**
- * Authenticate via NIP-42 flow.
- *
- * @example
- * const sign = window.nostr.signEvent
- * relay.on('auth', challenge =>
- *   authenticate({ relay, sign, challenge })
- * )
+ * creates an EventTemplate for an AUTH event to be signed.
  */
-export const authenticate = async ({
-  challenge,
-  relay,
-  sign,
-}: {
-  challenge: string
-  relay: Relay
-  sign: <K extends number = number>(e: EventTemplate<K>) => Promise<Event<K>> | Event<K>
-}): Promise<void> => {
-  const e: EventTemplate = {
-    kind: Kind.ClientAuth,
+export function makeAuthEvent(relayURL: string, challenge: string): EventTemplate {
+  return {
+    kind: ClientAuth,
     created_at: Math.floor(Date.now() / 1000),
     tags: [
-      ['relay', relay.url],
+      ['relay', relayURL],
       ['challenge', challenge],
     ],
     content: '',
   }
-  return relay.auth(await sign(e))
 }

nip44.test.ts

@@ -1,75 +0,0 @@
-import { encrypt, decrypt, utils } from './nip44.ts'
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils'
-import { v2 as vectors } from './nip44.vectors.json'
-import { getPublicKey } from './keys.ts'
-
-test('NIP44: valid_sec', async () => {
-  for (const v of vectors.valid_sec) {
-    const pub2 = getPublicKey(v.sec2)
-    const key = utils.v2.getConversationKey(v.sec1, pub2)
-    expect(bytesToHex(key)).toEqual(v.shared)
-    const ciphertext = encrypt(key, v.plaintext, { salt: hexToBytes(v.salt) })
-    expect(ciphertext).toEqual(v.ciphertext)
-    const decrypted = decrypt(key, ciphertext)
-    expect(decrypted).toEqual(v.plaintext)
-  }
-})
-
-test('NIP44: valid_pub', async () => {
-  for (const v of vectors.valid_pub) {
-    const key = utils.v2.getConversationKey(v.sec1, v.pub2)
-    expect(bytesToHex(key)).toEqual(v.shared)
-    const ciphertext = encrypt(key, v.plaintext, { salt: hexToBytes(v.salt) })
-    expect(ciphertext).toEqual(v.ciphertext)
-    const decrypted = decrypt(key, ciphertext)
-    expect(decrypted).toEqual(v.plaintext)
-  }
-})
-
-test('NIP44: invalid', async () => {
-  for (const v of vectors.invalid) {
-    expect(() => {
-      const key = utils.v2.getConversationKey(v.sec1, v.pub2)
-      const ciphertext = decrypt(key, v.ciphertext)
-    }).toThrowError(v.note)
-  }
-})
-
-test('NIP44: invalid_conversation_key', async () => {
-  for (const v of vectors.invalid_conversation_key) {
-    expect(() => {
-      const key = utils.v2.getConversationKey(v.sec1, v.pub2)
-      const ciphertext = encrypt(key, 'a')
-    }).toThrowError()
-  }
-})
-
-test('NIP44: v1 calcPadding', () => {
-  for (const [len, shouldBePaddedTo] of vectors.padding) {
-    const actual = utils.v2.calcPadding(len)
-    expect(actual).toEqual(shouldBePaddedTo)
-  }
-})
-
-// To re-generate vectors and produce new ones:
-// Create regen.mjs with this content:
-// import {getPublicKey, nip44} from './lib/esm/nostr.mjs'
-// import {bytesToHex, hexToBytes} from '@noble/hashes/utils'
-// import vectors from './nip44.vectors.json' assert { type: "json" };
-// function genVectors(v) {
-//   const pub2 = v.pub2 ?? getPublicKey(v.sec2);
-//   let sharedKey = nip44.utils.v2.getConversationKey(v.sec1, pub2)
-//   let ciphertext = nip44.encrypt(sharedKey, v.plaintext, { salt: hexToBytes(v.salt) })
-//   console.log({
-//     sec1: v.sec1,
-//     pub2: pub2,
-//     sharedKey: bytesToHex(sharedKey),
-//     salt: v.salt,
-//     plaintext: v.plaintext,
-//     ciphertext
-//   })
-// }
-// for (let v of vectors.valid_sec) genVectors(v);
-// for (let v of vectors.valid_pub) genVectors(v);
-// const padded = concatBytes(utils.v2.pad(plaintext), new Uint8Array(250))
-// const mac = randomBytes(32)

nip44.ts

@@ -1,107 +0,0 @@
-import { chacha20 } from '@noble/ciphers/chacha'
-import { ensureBytes, equalBytes } from '@noble/ciphers/utils'
-import { secp256k1 } from '@noble/curves/secp256k1'
-import { hkdf } from '@noble/hashes/hkdf'
-import { hmac } from '@noble/hashes/hmac'
-import { sha256 } from '@noble/hashes/sha256'
-import { concatBytes, randomBytes } from '@noble/hashes/utils'
-import { base64 } from '@scure/base'
-import { utf8Decoder, utf8Encoder } from './utils.ts'
-
-export const utils = {
-  v2: {
-    maxPlaintextSize: 65536 - 128, // 64kb - 128
-    minCiphertextSize: 100, // should be 128 if min padded to 32b: base64(1+32+32+32)
-    maxCiphertextSize: 102400, // 100kb
-
-    getConversationKey(privkeyA: string, pubkeyB: string): Uint8Array {
-      const key = secp256k1.getSharedSecret(privkeyA, '02' + pubkeyB)
-      return key.subarray(1, 33)
-    },
-
-    getMessageKeys(conversationKey: Uint8Array, salt: Uint8Array) {
-      const keys = hkdf(sha256, conversationKey, salt, 'nip44-v2', 76)
-      return {
-        encryption: keys.subarray(0, 32),
-        nonce: keys.subarray(32, 44),
-        auth: keys.subarray(44, 76),
-      }
-    },
-
-    calcPadding(len: number): number {
-      if (!Number.isSafeInteger(len) || len < 0) throw new Error('expected positive integer')
-      if (len <= 32) return 32
-      const nextpower = 1 << (Math.floor(Math.log2(len - 1)) + 1)
-      const chunk = nextpower <= 256 ? 32 : nextpower / 8
-      return chunk * (Math.floor((len - 1) / chunk) + 1)
-    },
-
-    pad(unpadded: string): Uint8Array {
-      const unpaddedB = utf8Encoder.encode(unpadded)
-      const len = unpaddedB.length
-      if (len < 1 || len >= utils.v2.maxPlaintextSize) throw new Error('invalid plaintext length: must be between 1b and 64KB')
-      const paddedLen = utils.v2.calcPadding(len)
-      const zeros = new Uint8Array(paddedLen - len)
-      const lenBuf = new Uint8Array(2)
-      new DataView(lenBuf.buffer).setUint16(0, len)
-      return concatBytes(lenBuf, unpaddedB, zeros)
-    },
-
-    unpad(padded: Uint8Array): string {
-      const unpaddedLen = new DataView(padded.buffer).getUint16(0)
-      const unpadded = padded.subarray(2, 2 + unpaddedLen)
-      if (
-        unpaddedLen === 0 ||
-        unpadded.length !== unpaddedLen ||
-        padded.length !== 2 + utils.v2.calcPadding(unpaddedLen)
-      )
-        throw new Error('invalid padding')
-      return utf8Decoder.decode(unpadded)
-    },
-  },
-}
-
-export function encrypt(
-  key: Uint8Array,
-  plaintext: string,
-  options: { salt?: Uint8Array; version?: number } = {},
-): string {
-  const version = options.version ?? 2
-  if (version !== 2) throw new Error('unknown encryption version ' + version)
-  const salt = options.salt ?? randomBytes(32)
-  ensureBytes(salt, 32)
-  const keys = utils.v2.getMessageKeys(key, salt)
-  const padded = utils.v2.pad(plaintext)
-  const ciphertext = chacha20(keys.encryption, keys.nonce, padded)
-  const mac = hmac(sha256, keys.auth, ciphertext)
-  return base64.encode(concatBytes(new Uint8Array([version]), salt, ciphertext, mac))
-}
-
-export function decrypt(key: Uint8Array, ciphertext: string): string {
-  const u = utils.v2
-  ensureBytes(key, 32)
-
-  const clen = ciphertext.length
-  if (clen < u.minCiphertextSize || clen >= u.maxCiphertextSize) throw new Error('invalid ciphertext length: ' + clen)
-
-  if (ciphertext[0] === '#') throw new Error('unknown encryption version')
-  let data: Uint8Array
-  try {
-    data = base64.decode(ciphertext)
-  } catch (error) {
-    throw new Error('invalid base64: ' + (error as any).message)
-  }
-  const vers = data.subarray(0, 1)[0]
-  if (vers !== 2) throw new Error('unknown encryption version ' + vers)
-
-  const salt = data.subarray(1, 33)
-  const ciphertext_ = data.subarray(33, -32)
-  const mac = data.subarray(-32)
-
-  const keys = u.getMessageKeys(key, salt)
-  const calculatedMac = hmac(sha256, keys.auth, ciphertext_)
-  if (!equalBytes(calculatedMac, mac)) throw new Error('invalid MAC')
-
-  const padded = chacha20(keys.encryption, keys.nonce, ciphertext_)
-  return u.unpad(padded)
-}

nip44.vectors.json

@@ -1,245 +0,0 @@
-{
-  "v2": {
-    "valid_sec": [
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000001",
-        "sec2": "0000000000000000000000000000000000000000000000000000000000000002",
-        "shared": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5",
-        "salt": "0000000000000000000000000000000000000000000000000000000000000001",
-        "plaintext": "a",
-        "ciphertext": "AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABYNpT9ESckRbRUY7bUF5P+1rObpA4BNoksAUQ8myMDd9/37W/J2YHvBpRjvy9uC0+ovbpLc0WLaMFieqAMdIYqR14",
-        "note": "sk1 = 1, sk2 = random, 0x02"
-      },
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000002",
-        "sec2": "0000000000000000000000000000000000000000000000000000000000000001",
-        "shared": "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5",
-        "salt": "f00000000000000000000000000000f00000000000000000000000000000000f",
-        "plaintext": "🍕🫃",
-        "ciphertext": "AvAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAAPKY68BwdF7PIT205jBoaZHSs7OMpKsULW5F5ClOJWiy6XjZy7s2v85KugYmbBKgEC2LytbXbxkr7Jpgfk529K3/pP",
-        "note": "sk1 = 1, sk2 = random, 0x02"
-      },
-      {
-        "sec1": "5c0c523f52a5b6fad39ed2403092df8cebc36318b39383bca6c00808626fab3a",
-        "sec2": "4b22aa260e4acb7021e32f38a6cdf4b673c6a277755bfce287e370c924dc936d",
-        "shared": "94da47d851b9c1ed33b3b72f35434f56aa608d60e573e9c295f568011f4f50a4",
-        "salt": "b635236c42db20f021bb8d1cdff5ca75dd1a0cc72ea742ad750f33010b24f73b",
-        "plaintext": "表ポあA鷗ŒéＢ逍Üߪąñ丂㐀𠀀",
-        "ciphertext": "ArY1I2xC2yDwIbuNHN/1ynXdGgzHLqdCrXUPMwELJPc7yuU7XwJ8wCYUrq4aXX86HLnkMx7fPFvNeMk0uek9ma01magfEBIf+vJvZdWKiv48eUu9Cv31plAJsH6kSIsGc5TVYBYipkrQUNRxxJA15QT+uCURF96v3XuSS0k2Pf108AI=",
-        "note": "unicode-heavy string"
-      },
-      {
-        "sec1": "8f40e50a84a7462e2b8d24c28898ef1f23359fff50d8c509e6fb7ce06e142f9c",
-        "sec2": "b9b0a1e9cc20100c5faa3bbe2777303d25950616c4c6a3fa2e3e046f936ec2ba",
-        "shared": "ab99c122d4586cdd5c813058aa543d0e7233545dbf6874fc34a3d8d9a18fbbc3",
-        "salt": "b20989adc3ddc41cd2c435952c0d59a91315d8c5218d5040573fc3749543acaf",
-        "plaintext": "ability🤝的 ȺȾ",
-        "ciphertext": "ArIJia3D3cQc0sQ1lSwNWakTFdjFIY1QQFc/w3SVQ6yvPSc+7YCIFTmGk5OLuh1nhl6TvID7sGKLFUCWRW1eRfV/0a7sT46N3nTQzD7IE67zLWrYqGnE+0DDNz6sJ4hAaFrT"
-      },
-      {
-        "sec1": "875adb475056aec0b4809bd2db9aa00cff53a649e7b59d8edcbf4e6330b0995c",
-        "sec2": "9c05781112d5b0a2a7148a222e50e0bd891d6b60c5483f03456e982185944aae",
-        "shared": "a449f2a85c6d3db0f44c64554a05d11a3c0988d645e4b4b2592072f63662f422",
-        "salt": "8d4442713eb9d4791175cb040d98d6fc5be8864d6ec2f89cf0895a2b2b72d1b1",
-        "plaintext": "pepper👀їжак",
-        "ciphertext": "Ao1EQnE+udR5EXXLBA2Y1vxb6IZNbsL4nPCJWisrctGx1TkkMfiHJxEeSdQ/4Rlaghn0okDCNYLihBsHrDzBsNRC27APmH9mmZcpcg66Mb0exH9V5/lLBWdQW+fcY9GpvXv0"
-      },
-      {
-        "sec1": "eba1687cab6a3101bfc68fd70f214aa4cc059e9ec1b79fdb9ad0a0a4e259829f",
-        "sec2": "dff20d262bef9dfd94666548f556393085e6ea421c8af86e9d333fa8747e94b3",
-        "shared": "decde9938ffcb14fa7ff300105eb1bf239469af9baf376e69755b9070ae48c47",
-        "salt": "2180b52ae645fcf9f5080d81b1f0b5d6f2cd77ff3c986882bb549158462f3407",
-        "plaintext": "( ͡° ͜ʖ ͡°)",
-        "ciphertext": "AiGAtSrmRfz59QgNgbHwtdbyzXf/PJhogrtUkVhGLzQHiR8Hljs6Nl/XsNDAmCz6U1Z3NUGhbCtczc3wXXxDzFkjjMimxsf/74OEzu7LphUadM9iSWvVKPrNXY7lTD0B2muz"
-      },
-      {
-        "sec1": "d5633530f5bcfebceb5584cfbbf718a30df0751b729dd9a789b9f30c0587d74e",
-        "sec2": "b74e6a341fb134127272b795a08b59250e5fa45a82a2eb4095e4ce9ed5f5e214",
-        "shared": "c6f2fde7aa00208c388f506455c31c3fa07caf8b516d43bf7514ee19edcda994",
-        "salt": "e4cd5f7ce4eea024bc71b17ad456a986a74ac426c2c62b0a15eb5c5c8f888b68",
-        "plaintext": "مُنَاقَشَةُ سُبُلِ اِسْتِخْدَامِ اللُّغَةِ فِي النُّظُمِ الْقَائِمَةِ وَفِيم يَخُصَّ التَّطْبِيقَاتُ الْحاسُوبِيَّةُ،",
-        "ciphertext": "AuTNX3zk7qAkvHGxetRWqYanSsQmwsYrChXrXFyPiItohfde4vHVRHUupr+Glh9JW4f9EY+w795hvRZbixs0EQgDZ7zwLlymVQI3NNvMqvemQzHUA1I5+9gSu8XSMwX9gDCUAjUJtntCkRt9+tjdy2Wa2ZrDYqCvgirvzbJTIC69Ve3YbKuiTQCKtVi0PA5ZLqVmnkHPIqfPqDOGj/a3dvJVzGSgeijcIpjuEgFF54uirrWvIWmTBDeTA+tlQzJHpB2wQnUndd2gLDb8+eKFUZPBifshD3WmgWxv8wRv6k3DeWuWEZQ70Z+YDpgpeOzuzHj0MDBwMAlY8Qq86Rx6pxY76PLDDfHh3rE2CHJEKl2MhDj7pGXao2o633vSRd9ueG8W"
-      },
-      {
-        "sec1": "d5633530f5bcfebceb5584cfbbf718a30df0751b729dd9a789b9f30c0587d74e",
-        "sec2": "b74e6a341fb134127272b795a08b59250e5fa45a82a2eb4095e4ce9ed5f5e214",
-        "shared": "c6f2fde7aa00208c388f506455c31c3fa07caf8b516d43bf7514ee19edcda994",
-        "salt": "38d1ca0abef9e5f564e89761a86cee04574b6825d3ef2063b10ad75899e4b023",
-        "plaintext": "الكل في المجمو عة (5)",
-        "ciphertext": "AjjRygq++eX1ZOiXYahs7gRXS2gl0+8gY7EK11iZ5LAjTHmhdBC3meTY4A7Lv8s8B86MnmlUBJ8ebzwxFQzDyVCcdSbWFaKe0gigEBdXew7TjrjH8BCpAbtYjoa4YHa8GNjj7zH314ApVnwoByHdLHLB9Vr6VdzkxcJgA6oL4MAsRLg="
-      },
-      {
-        "sec1": "d5633530f5bcfebceb5584cfbbf718a30df0751b729dd9a789b9f30c0587d74e",
-        "sec2": "b74e6a341fb134127272b795a08b59250e5fa45a82a2eb4095e4ce9ed5f5e214",
-        "shared": "c6f2fde7aa00208c388f506455c31c3fa07caf8b516d43bf7514ee19edcda994",
-        "salt": "4f1a31909f3483a9e69c8549a55bbc9af25fa5bbecf7bd32d9896f83ef2e12e0",
-        "plaintext": "𝖑𝖆𝖟𝖞 社會科學院語學研究所",
-        "ciphertext": "Ak8aMZCfNIOp5pyFSaVbvJryX6W77Pe9MtmJb4PvLhLg/25Q5uBC88jl5ghtEREXX6o4QijPzM0uwmkeQ54/6aIqUyzGNVdryWKZ0mee2lmVVWhU+26X6XGFQ5DGRn+1v0POsFUCZ/REh35+beBNHnyvjxD/rbrMfhP2Blc8X5m8Xvk="
-      },
-      {
-        "sec1": "d5633530f5bcfebceb5584cfbbf718a30df0751b729dd9a789b9f30c0587d74e",
-        "sec2": "b74e6a341fb134127272b795a08b59250e5fa45a82a2eb4095e4ce9ed5f5e214",
-        "shared": "c6f2fde7aa00208c388f506455c31c3fa07caf8b516d43bf7514ee19edcda994",
-        "salt": "a3e219242d85465e70adcd640b564b3feff57d2ef8745d5e7a0663b2dccceb54",
-        "plaintext": "🙈 🙉 🙊 0️⃣ 1️⃣ 2️⃣ 3️⃣ 4️⃣ 5️⃣ 6️⃣ 7️⃣ 8️⃣ 9️⃣ 🔟 Powerلُلُصّبُلُلصّبُررً ॣ ॣh ॣ ॣ冗",
-        "ciphertext": "AqPiGSQthUZecK3NZAtWSz/v9X0u+HRdXnoGY7LczOtU9bUC2ji2A2udRI2VCEQZ7IAmYRRgxodBtd5Yi/5htCUczf1jLHxIt9AhVAZLKuRgbWOuEMq5RBybkxPsSeAkxzXVOlWHZ1Febq5ogkjqY/6Xj8CwwmaZxfbx+d1BKKO3Wa+IFuXwuVAZa1Xo+fan+skyf+2R5QSj10QGAnGO7odAu/iZ9A28eMoSNeXsdxqy1+PRt5Zk4i019xmf7C4PDGSzgFZSvQ2EzusJN5WcsnRFmF1L5rXpX1AYo8HusOpWcGf9PjmFbO+8spUkX1W/T21GRm4o7dro1Y6ycgGOA9BsiQ=="
-      }
-    ],
-    "valid_pub": [
-      {
-        "sec1": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364139",
-        "pub2": "0000000000000000000000000000000000000000000000000000000000000002",
-        "shared": "7a1ccf5ce5a08e380f590de0c02776623b85a61ae67cfb6a017317e505b7cb51",
-        "salt": "a000000000000000000000000000000000000000000000000000000000000001",
-        "plaintext": "⁰⁴⁵₀₁₂",
-        "ciphertext": "AqAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB2+xmGnjIMPMqqJGmjdYAYZUDUyEEUO3/evHUaO40LePeR91VlMVZ7I+nKJPkaUiKZ3cQiQnA86Uwti2IxepmzOFN",
-        "note": "sec1 = n-2, pub2: random, 0x02"
-      },
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000002",
-        "pub2": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdeb",
-        "shared": "aa971537d741089885a0b48f2730a125e15b36033d089d4537a4e1204e76b39e",
-        "salt": "b000000000000000000000000000000000000000000000000000000000000002",
-        "plaintext": "A Peer-to-Peer Electronic Cash System",
-        "ciphertext": "ArAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACyuqG6RycuPyDPtwxzTcuMQu+is3N5XuWTlvCjligVaVBRydexaylXbsX592MEd3/Jt13BNL/GlpYpGDvLS4Tt/+2s9FX/16e/RDc+czdwXglc4DdSHiq+O06BvvXYfEQOPw=",
-        "note": "sec1 = 2, pub2: "
-      },
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000001",
-        "pub2": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        "shared": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        "salt": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-        "plaintext": "A purely peer-to-peer version of electronic cash would allow online payments to be sent directly from one party to another without going through a financial institution. Digital signatures provide part of the solution, but the main benefits are lost if a trusted third party is still required to prevent double-spending.",
-        "ciphertext": "Anm+Zn753LusVaBilc6HCwcCm/zbLc4o2VnygVsW+BeYb9wHyKevpe7ohJ6OkpceFcb0pySY8TLGwT7Q3zWNDKxc9blXanxKborEXkQH8xNaB2ViJfgxpkutbwbYd0Grix34xzaZBASufdsNm7R768t51tI6sdS0nms6kWLVJpEGu6Ke4Bldv4StJtWBLaTcgsgN+4WxDbBhC/nhwjEQiBBbbmUrPWjaVZXjl8dzzPrYtkSoeBNJs/UNvDwym4+qrmhv4ASTvVflpZgLlSe4seqeu6dWoRqn8uRHZQnPs+XhqwbdCHpeKGB3AfGBykZY0RIr0tjarWdXNasGbIhGM3GiLasioJeabAZw0plCevDkKpZYDaNfMJdzqFVJ8UXRIpvDpQad0SOm8lLum/aBzUpLqTjr3RvSlhYdbuODpd9pR5K60k4L2N8nrPtBv08wlilQg2ymwQgKVE6ipxIzzKMetn8+f0nQ9bHjWFJqxetSuMzzArTUQl9c4q/DwZmCBhI2",
-        "note": "sec1 == pub2 == salt"
-      }
-    ],
-    "invalid": [
-      {
-        "sec1": "2573d1e9b9ac5de5d570f652cbb9e8d4f235e3d3d334181448e87c417f374e83",
-        "pub2": "8348c2d35549098706e5bab7966d9a9c72fbf6554e918f41c2b6cb275f79ec13",
-        "sharedKey": "8673ec68393a997bfad7eab8661461daf8b3931b7e885d78312a3fb7fe17f41a",
-        "salt": "daaea5ca345b268e5b62060ca72c870c48f713bc1e00ff3fc0ddb78e826f10db",
-        "plaintext": "n o b l e",
-        "ciphertext": "##Atqupco0WyaOW2IGDKcshwxI9xO8HgD/P8Ddt46CbxDbOsrsqIEyf8ccwhlrnI/Cx03mDSmeweOLKD7dw5BDZQDxXe2FwUJ8Ag25VoJ4MGhjlPCNmCU/Uqk4k0jwbhgR3fRh",
-        "note": "unknown encryption version"
-      },
-      {
-        "sec1": "11063318c5cb3cd9cafcced42b4db5ea02ec976ed995962d2bc1fa1e9b52e29f",
-        "pub2": "5c49873b6eac3dd363325250cc55d5dd4c7ce9a885134580405736d83506bb74",
-        "sharedKey": "e2aad10de00913088e5cb0f73fa526a6a17e95763cc5b2a127022f5ea5a73445",
-        "salt": "ad408d4be8616dc84bb0bf046454a2a102edac937c35209c43cd7964c5feb781",
-        "plaintext": "⚠️",
-        "ciphertext": "AK1AjUvoYW3IS7C/BGRUoqEC7ayTfDUgnEPNeWTF/reBA4fZmoHrtrz5I5pCHuwWZ22qqL/Xt1VidEZGMLds0yaJ5VwUbeEifEJlPICOFt1ssZJxCUf43HvRwCVTFskbhSMh",
-        "note": "unknown encryption version 0"
-      },
-      {
-        "sec1": "2573d1e9b9ac5de5d570f652cbb9e8d4f235e3d3d334181448e87c417f374e83",
-        "pub2": "8348c2d35549098706e5bab7966d9a9c72fbf6554e918f41c2b6cb275f79ec13",
-        "sharedKey": "8673ec68393a997bfad7eab8661461daf8b3931b7e885d78312a3fb7fe17f41a",
-        "salt": "daaea5ca345b268e5b62060ca72c870c48f713bc1e00ff3fc0ddb78e826f10db",
-        "plaintext": "n o s t r",
-        "ciphertext": "Atqupco0WyaOW2IGDKcshwxI9xO8HgD/P8Ddt46CbxDbOsrsqIEybscEwg5rnI/Cx03mDSmeweOLKD,7dw5BDZQDxXSlCwX1LIcTJEZaJPTz98Ftu0zSE0d93ED7OtdlvNeZx",
-        "note": "invalid base64"
-      },
-      {
-        "sec1": "5a2f39347fed3883c9fe05868a8f6156a292c45f606bc610495fcc020ed158f7",
-        "pub2": "775bbfeba58d07f9d1fbb862e306ac780f39e5418043dadb547c7b5900245e71",
-        "sharedKey": "2e70c0a1cde884b88392458ca86148d859b273a5695ede5bbe41f731d7d88ffd",
-        "salt": "09ff97750b084012e15ecb84614ce88180d7b8ec0d468508a86b6d70c0361a25",
-        "plaintext": "¯\\_(ツ)_/¯",
-        "ciphertext": "Agn/l3ULCEAS4V7LhGFM6IGA17jsDUaFCKhrbXDANholdUejFZPARM22IvOqp1U/UmFSkeSyTBYbbwy5ykmi+mKiEcWL+nVmTOf28MMiC+rTpZys/8p1hqQFpn+XWZRPrVay",
-        "note": "invalid MAC"
-      },
-      {
-        "sec1": "067eda13c4a36090ad28a7a183e9df611186ca01f63cb30fcdfa615ebfd6fb6d",
-        "pub2": "32c1ece2c5dd2160ad03b243f50eff12db605b86ac92da47eacc78144bf0cdd3",
-        "sharedKey": "a808915e31afc5b853d654d2519632dac7298ee2ecddc11695b8eba925935c2a",
-        "salt": "65b14b0b949aaa7d52c417eb753b390e8ad6d84b23af4bec6d9bfa3e03a08af4",
-        "plaintext": "🥎",
-        "ciphertext": "AmWxSwuUmqp9UsQX63U7OQ6K1thLI69L7G2b+j4DoIr0U0P/M1/oKm95z8qz6Kg0zQawLzwk3DskvWA2drXP4zK+tzHpKvWq0KOdx5MdypboSQsP4NXfhh2KoUffjkyIOiMA",
-        "note": "invalid MAC"
-      },
-      {
-        "sec1": "3e7be560fb9f8c965c48953dbd00411d48577e200cf00d7cc427e49d0e8d9c01",
-        "pub2": "e539e5fee58a337307e2a937ee9a7561b45876fb5df405c5e7be3ee564b239cc",
-        "sharedKey": "6ee3efc4255e3b8270e5dd3f7dc7f6b60878cda6218c8df34a3261cd48744931",
-        "salt": "7ab65dbb8bbc2b8e35cafb5745314e1f050325a864d11d0475ef75b3660d91c1",
-        "plaintext": "elliptic-curve cryptography",
-        "ciphertext": "Anq2XbuLvCuONcr7V0UxTh8FAyWoZNEdBHXvdbNmDZHBu7F9m36yBd58mVUBB5ktBTOJREDaQT1KAyPmZidP+IRea1lNw5YAEK7+pbnpfCw8CD0i2n8Pf2IDWlKDhLiVvatw",
-        "note": "invalid padding"
-      },
-      {
-        "sec1": "c22e1d4de967aa39dc143354d8f596cec1d7c912c3140831fff2976ce3e387c1",
-        "pub2": "4e405be192677a2da95ffc733950777213bf880cf7c3b084eeb6f3fe5bd43705",
-        "sharedKey": "1675a773dbf6fbcbef6a293004a4504b6c856978be738b10584b0269d437c8d1",
-        "salt": "7d4283e3b54c885d6afee881f48e62f0a3f5d7a9e1cb71ccab594a7882c39330",
-        "plaintext": "Peer-to-Peer",
-        "ciphertext": "An1Cg+O1TIhdav7ogfSOYvCj9dep4ctxzKtZSniCw5MwhT0hvSnF9Xjp9Lml792qtNbmAVvR6laukTe9eYEjeWPpZFxtkVpYTbbL9wDKFeplDMKsUKVa+roSeSvv0ela9seDVl2Sfso=",
-        "note": "invalid padding"
-      },
-      {
-        "sec1": "be1edab14c5912e5c59084f197f0945242e969c363096cccb59af8898815096f",
-        "pub2": "9eaf0775d971e4941c97189232542e1daefcdb7dddafc39bcea2520217710ba2",
-        "sharedKey": "1741a44c052d5ae363c7845441f73d2b6c28d9bfb3006190012bba12eb4c774b",
-        "salt": "6f9fd72667c273acd23ca6653711a708434474dd9eb15c3edb01ce9a95743e9b",
-        "plaintext": "censorship-resistant and global social network",
-        "ciphertext": "Am+f1yZnwnOs0jymZTcRpwhDRHTdnrFcPtsBzpqVdD6bL9HUMo3Mjkz4bjQo/FJF2LWHmaCr9Byc3hU9D7we+EkNBWenBHasT1G52fZk9r3NKeOC1hLezNwBLr7XXiULh+NbMBDtJh9/aQh1uZ9EpAfeISOzbZXwYwf0P5M85g9XER8hZ2fgJDLb4qMOuQRG6CrPezhr357nS3UHwPC2qHo3uKACxhE+2td+965yDcvMTx4KYTQg1zNhd7PA5v/WPnWeq2B623yLxlevUuo/OvXplFho3QVy7s5QZVop6qV2g2/l/SIsvD0HIcv3V35sywOCBR0K4VHgduFqkx/LEF3NGgAbjONXQHX8ZKushsEeR4TxlFoRSovAyYjhWolz+Ok3KJL2Ertds3H+M/Bdl2WnZGT0IbjZjn3DS+b1Ke0R0X4Onww2ZG3+7o6ncIwTc+lh1O7YQn00V0HJ+EIp03heKV2zWdVSC615By/+Yt9KAiV56n5+02GAuNqA",
-        "note": "invalid padding"
-      }
-    ],
-    "invalid_conversation_key": [
-      {
-        "sec1": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "pub2": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
-        "note": "sec1 higher than curve.n"
-      },
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000000",
-        "pub2": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
-        "note": "sec1 is 0"
-      },
-      {
-        "sec1": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364139",
-        "pub2": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "note": "pub2 is invalid, no sqrt, all-ff"
-      },
-      {
-        "sec1": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
-        "pub2": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
-        "note": "sec1 == curve.n"
-      },
-      {
-        "sec1": "0000000000000000000000000000000000000000000000000000000000000002",
-        "pub2": "1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
-        "note": "pub2 is invalid, no sqrt"
-      }
-    ],
-    "padding": [
-      [16, 32],
-      [32, 32],
-      [33, 64],
-      [37, 64],
-      [45, 64],
-      [49, 64],
-      [64, 64],
-      [65, 96],
-      [100, 128],
-      [111, 128],
-      [200, 224],
-      [250, 256],
-      [320, 320],
-      [383, 384],
-      [384, 384],
-      [400, 448],
-      [500, 512],
-      [512, 512],
-      [515, 640],
-      [700, 768],
-      [800, 896],
-      [900, 1024],
-      [1020, 1024],
-      [74123, 81920]
-    ]
-  }
-}

nip47.test.ts

@@ -1,7 +1,9 @@
-import { makeNwcRequestEvent, parseConnectionString } from './nip47'
-import { Kind } from './event'
-import { decrypt } from './nip04.ts'
 import crypto from 'node:crypto'
+import { describe, test, expect } from 'bun:test'
+import { hexToBytes } from '@noble/hashes/utils'
+import { makeNwcRequestEvent, parseConnectionString } from './nip47'
+import { decrypt } from './nip04.ts'
+import { NWCWalletRequest } from './kinds.ts'
 
 // @ts-ignore
 // eslint-disable-next-line no-undef
@@ -43,19 +45,11 @@ describe('parseConnectionString', () => {
 describe('makeNwcRequestEvent', () => {
   test('returns a valid NWC request event', async () => {
     const pubkey = 'b889ff5b1513b641e2a139f661a661364979c5beee91842f8f0ef42ab558e9d4'
-    const secret = '71a8c14c1407c113601079c4302dab36460f0ccd0ad506f1f2dc73b5100e4f3c'
+    const secret = hexToBytes('71a8c14c1407c113601079c4302dab36460f0ccd0ad506f1f2dc73b5100e4f3c')
     const invoice =
       'lnbc210n1pjdgyvupp5x43awdarnfd4mdlsklelux0nyckwfu5c708ykuet8vcjnjp3rnpqdqu2askcmr9wssx7e3q2dshgmmndp5scqzzsxqyz5vqsp52l7y9peq9pka3vd3j7aps7gjnalsmy46ndj2mlkz00dltjgqfumq9qyyssq5fasr5dxed8l4qjfnqq48a02jzss3asf8sly7sfaqtr9w3yu2q9spsxhghs3y9aqdf44zkrrg9jjjdg6amade4h0hulllkwk33eqpucp6d5jye'
-    const timeBefore = Date.now() / 1000
-    const result = await makeNwcRequestEvent({
-      pubkey,
-      secret,
-      invoice,
-    })
-    const timeAfter = Date.now() / 1000
-    expect(result.kind).toBe(Kind.NwcRequest)
-    expect(result.created_at).toBeGreaterThan(timeBefore)
-    expect(result.created_at).toBeLessThan(timeAfter)
+    const result = await makeNwcRequestEvent(pubkey, secret, invoice)
+    expect(result.kind).toBe(NWCWalletRequest)
     expect(await decrypt(secret, pubkey, result.content)).toEqual(
       JSON.stringify({
         method: 'pay_invoice',

nip47.ts

@@ -1,6 +1,6 @@
-import { finishEvent } from './event.ts'
+import { finalizeEvent } from './pure.ts'
+import { NWCWalletRequest } from './kinds.ts'
 import { encrypt } from './nip04.ts'
-import { Kind } from './event'
 
 export function parseConnectionString(connectionString: string) {
   const { pathname, searchParams } = new URL(connectionString)
@@ -15,28 +15,20 @@ export function parseConnectionString(connectionString: string) {
   return { pubkey, relay, secret }
 }
 
-export async function makeNwcRequestEvent({
-  pubkey,
-  secret,
-  invoice,
-}: {
-  pubkey: string
-  secret: string
-  invoice: string
-}) {
+export async function makeNwcRequestEvent(pubkey: string, secretKey: Uint8Array, invoice: string) {
   const content = {
     method: 'pay_invoice',
     params: {
       invoice,
     },
   }
-  const encryptedContent = await encrypt(secret, pubkey, JSON.stringify(content))
+  const encryptedContent = await encrypt(secretKey, pubkey, JSON.stringify(content))
   const eventTemplate = {
-    kind: Kind.NwcRequest,
+    kind: NWCWalletRequest,
     created_at: Math.round(Date.now() / 1000),
     content: encryptedContent,
     tags: [['p', pubkey]],
   }
 
-  return finishEvent(eventTemplate, secret)
+  return finalizeEvent(eventTemplate, secretKey)
 }

nip57.test.ts

@@ -1,5 +1,6 @@
-import { finishEvent } from './event.ts'
-import { getPublicKey, generatePrivateKey } from './keys.ts'
+import { describe, test, expect, mock } from 'bun:test'
+import { finalizeEvent } from './pure.ts'
+import { getPublicKey, generateSecretKey } from './pure.ts'
 import { getZapEndpoint, makeZapReceipt, makeZapRequest, useFetchImplementation, validateZapRequest } from './nip57.ts'
 import { buildEvent } from './test-helpers.ts'
 
@@ -12,7 +13,7 @@ describe('getZapEndpoint', () => {
   })
 
   test('returns null if fetch fails', async () => {
-    const fetchImplementation = jest.fn(() => Promise.reject(new Error()))
+    const fetchImplementation = mock(() => Promise.reject(new Error()))
     useFetchImplementation(fetchImplementation)
 
     const metadata = buildEvent({ kind: 0, content: '{"lud16": "name@domain"}' })
@@ -23,7 +24,7 @@ describe('getZapEndpoint', () => {
   })
 
   test('returns null if the response does not allow Nostr payments', async () => {
-    const fetchImplementation = jest.fn(() => Promise.resolve({ json: () => ({ allowsNostr: false }) }))
+    const fetchImplementation = mock(() => Promise.resolve({ json: () => ({ allowsNostr: false }) }))
     useFetchImplementation(fetchImplementation)
 
     const metadata = buildEvent({ kind: 0, content: '{"lud16": "name@domain"}' })
@@ -34,7 +35,7 @@ describe('getZapEndpoint', () => {
   })
 
   test('returns the callback URL if the response allows Nostr payments', async () => {
-    const fetchImplementation = jest.fn(() =>
+    const fetchImplementation = mock(() =>
       Promise.resolve({
         json: () => ({
           allowsNostr: true,
@@ -94,9 +95,9 @@ describe('makeZapRequest', () => {
         ['p', 'profile'],
         ['amount', '100'],
         ['relays', 'relay1', 'relay2'],
+        ['e', 'event'],
       ]),
     )
-    expect(result.tags).toContainEqual(['e', 'event'])
   })
 })
 
@@ -121,7 +122,7 @@ describe('validateZapRequest', () => {
   })
 
   test('returns an error message if the signature on the Zap request is invalid', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
     const zapRequest = {
@@ -140,9 +141,8 @@ describe('validateZapRequest', () => {
   })
 
   test('returns an error message if the Zap request does not have a "p" tag', () => {
-    const privateKey = generatePrivateKey()
-
-    const zapRequest = finishEvent(
+    const privateKey = generateSecretKey()
+    const zapRequest = finalizeEvent(
       {
         kind: 9734,
         created_at: Date.now() / 1000,
@@ -159,9 +159,8 @@ describe('validateZapRequest', () => {
   })
 
   test('returns an error message if the "p" tag on the Zap request is not valid hex', () => {
-    const privateKey = generatePrivateKey()
-
-    const zapRequest = finishEvent(
+    const privateKey = generateSecretKey()
+    const zapRequest = finalizeEvent(
       {
         kind: 9734,
         created_at: Date.now() / 1000,
@@ -179,10 +178,10 @@ describe('validateZapRequest', () => {
   })
 
   test('returns an error message if the "e" tag on the Zap request is not valid hex', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
-    const zapRequest = finishEvent(
+    const zapRequest = finalizeEvent(
       {
         kind: 9734,
         created_at: Date.now() / 1000,
@@ -201,10 +200,10 @@ describe('validateZapRequest', () => {
   })
 
   test('returns an error message if the Zap request does not have a relays tag', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
-    const zapRequest = finishEvent(
+    const zapRequest = finalizeEvent(
       {
         kind: 9734,
         created_at: Date.now() / 1000,
@@ -221,10 +220,10 @@ describe('validateZapRequest', () => {
   })
 
   test('returns null for a valid Zap request', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
-    const zapRequest = finishEvent(
+    const zapRequest = finalizeEvent(
       {
         kind: 9734,
         created_at: Date.now() / 1000,
@@ -244,11 +243,11 @@ describe('validateZapRequest', () => {
 
 describe('makeZapReceipt', () => {
   test('returns a valid Zap receipt with a preimage', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
     const zapRequest = JSON.stringify(
-      finishEvent(
+      finalizeEvent(
         {
           kind: 9734,
           created_at: Date.now() / 1000,
@@ -271,18 +270,22 @@ describe('makeZapReceipt', () => {
     expect(result.kind).toBe(9735)
     expect(result.created_at).toBeCloseTo(paidAt.getTime() / 1000, 0)
     expect(result.content).toBe('')
-    expect(result.tags).toContainEqual(['bolt11', bolt11])
-    expect(result.tags).toContainEqual(['description', zapRequest])
-    expect(result.tags).toContainEqual(['p', publicKey])
-    expect(result.tags).toContainEqual(['preimage', preimage])
+    expect(result.tags).toEqual(
+      expect.arrayContaining([
+        ['bolt11', bolt11],
+        ['description', zapRequest],
+        ['p', publicKey],
+        ['preimage', preimage],
+      ]),
+    )
   })
 
   test('returns a valid Zap receipt without a preimage', () => {
-    const privateKey = generatePrivateKey()
+    const privateKey = generateSecretKey()
     const publicKey = getPublicKey(privateKey)
 
     const zapRequest = JSON.stringify(
-      finishEvent(
+      finalizeEvent(
         {
           kind: 9734,
           created_at: Date.now() / 1000,
@@ -304,9 +307,13 @@ describe('makeZapReceipt', () => {
     expect(result.kind).toBe(9735)
     expect(result.created_at).toBeCloseTo(paidAt.getTime() / 1000, 0)
     expect(result.content).toBe('')
-    expect(result.tags).toContainEqual(['bolt11', bolt11])
-    expect(result.tags).toContainEqual(['description', zapRequest])
-    expect(result.tags).toContainEqual(['p', publicKey])
-    expect(result.tags).not.toContain('preimage')
+    expect(result.tags).toEqual(
+      expect.arrayContaining([
+        ['bolt11', bolt11],
+        ['description', zapRequest],
+        ['p', publicKey],
+      ]),
+    )
+    expect(JSON.stringify(result.tags)).not.toContain('preimage')
   })
 })

nip57.ts

@@ -1,6 +1,6 @@
 import { bech32 } from '@scure/base'
 
-import { Kind, validateEvent, verifySignature, type Event, type EventTemplate } from './event.ts'
+import { validateEvent, verifyEvent, type Event, type EventTemplate } from './pure.ts'
 import { utf8Decoder } from './utils.ts'
 
 var _fetch: any
@@ -58,7 +58,7 @@ export function makeZapRequest({
   if (!profile) throw new Error('profile not given')
 
   let zr: EventTemplate = {
-    kind: Kind.ZapRequest,
+    kind: 9734,
     created_at: Math.round(Date.now() / 1000),
     content: comment,
     tags: [
@@ -86,7 +86,7 @@ export function validateZapRequest(zapRequestString: string): string | null {
 
   if (!validateEvent(zapRequest)) return 'Zap request is not a valid Nostr event.'
 
-  if (!verifySignature(zapRequest)) return 'Invalid signature on zap request.'
+  if (!verifyEvent(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."
@@ -116,7 +116,7 @@ export function makeZapReceipt({
   let tagsFromZapRequest = zr.tags.filter(([t]) => t === 'e' || t === 'p' || t === 'a')
 
   let zap: EventTemplate = {
-    kind: Kind.Zap,
+    kind: 9735,
     created_at: Math.round(paidAt.getTime() / 1000),
     content: '',
     tags: [...tagsFromZapRequest, ['bolt11', bolt11], ['description', zapRequest]],

nip98.test.ts

@@ -1,18 +1,23 @@
+import { describe, test, expect } from 'bun:test'
 import { getToken, unpackEventFromToken, validateEvent, validateToken } from './nip98.ts'
-import { Event, Kind, finishEvent } from './event.ts'
-import { generatePrivateKey, getPublicKey } from './keys.ts'
+import { Event, finalizeEvent } from './pure.ts'
+import { generateSecretKey, getPublicKey } from './pure.ts'
+import { sha256 } from '@noble/hashes/sha256'
+import { utf8Encoder } from './utils.ts'
+import { bytesToHex } from '@noble/hashes/utils'
+import { HTTPAuth } from './kinds.ts'
 
-const sk = generatePrivateKey()
+const sk = generateSecretKey()
 
 describe('getToken', () => {
   test('getToken GET returns without authorization scheme', async () => {
-    let result = await getToken('http://test.com', 'get', e => finishEvent(e, sk))
+    let result = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk))
 
     const decodedResult: Event = await unpackEventFromToken(result)
 
     expect(decodedResult.created_at).toBeGreaterThan(0)
     expect(decodedResult.content).toBe('')
-    expect(decodedResult.kind).toBe(Kind.HttpAuth)
+    expect(decodedResult.kind).toBe(HTTPAuth)
     expect(decodedResult.pubkey).toBe(getPublicKey(sk))
     expect(decodedResult.tags).toStrictEqual([
       ['u', 'http://test.com'],
@@ -21,13 +26,13 @@ describe('getToken', () => {
   })
 
   test('getToken POST returns token without authorization scheme', async () => {
-    let result = await getToken('http://test.com', 'post', e => finishEvent(e, sk))
+    let result = await getToken('http://test.com', 'post', e => finalizeEvent(e, sk))
 
     const decodedResult: Event = await unpackEventFromToken(result)
 
     expect(decodedResult.created_at).toBeGreaterThan(0)
     expect(decodedResult.content).toBe('')
-    expect(decodedResult.kind).toBe(Kind.HttpAuth)
+    expect(decodedResult.kind).toBe(HTTPAuth)
     expect(decodedResult.pubkey).toBe(getPublicKey(sk))
     expect(decodedResult.tags).toStrictEqual([
       ['u', 'http://test.com'],
@@ -38,7 +43,7 @@ describe('getToken', () => {
   test('getToken GET returns token WITH authorization scheme', async () => {
     const authorizationScheme = 'Nostr '
 
-    let result = await getToken('http://test.com', 'post', e => finishEvent(e, sk), true)
+    let result = await getToken('http://test.com', 'post', e => finalizeEvent(e, sk), true)
 
     expect(result.startsWith(authorizationScheme)).toBe(true)
 
@@ -46,7 +51,7 @@ describe('getToken', () => {
 
     expect(decodedResult.created_at).toBeGreaterThan(0)
     expect(decodedResult.content).toBe('')
-    expect(decodedResult.kind).toBe(Kind.HttpAuth)
+    expect(decodedResult.kind).toBe(HTTPAuth)
     expect(decodedResult.pubkey).toBe(getPublicKey(sk))
     expect(decodedResult.tags).toStrictEqual([
       ['u', 'http://test.com'],
@@ -54,27 +59,35 @@ describe('getToken', () => {
     ])
   })
 
-  test('getToken missing loginUrl throws an error', async () => {
-    const result = getToken('', 'get', e => finishEvent(e, sk))
-    await expect(result).rejects.toThrow(Error)
-  })
+  test('getToken returns token with a valid payload tag when payload is present', async () => {
+    const payload = { test: 'payload' }
+    const payloadHash = bytesToHex(sha256(utf8Encoder.encode(JSON.stringify(payload))))
+    let result = await getToken('http://test.com', 'post', e => finalizeEvent(e, sk), true, payload)
 
-  test('getToken missing httpMethod throws an error', async () => {
-    const result = getToken('http://test.com', '', e => finishEvent(e, sk))
-    await expect(result).rejects.toThrow(Error)
+    const decodedResult: Event = await unpackEventFromToken(result)
+
+    expect(decodedResult.created_at).toBeGreaterThan(0)
+    expect(decodedResult.content).toBe('')
+    expect(decodedResult.kind).toBe(HTTPAuth)
+    expect(decodedResult.pubkey).toBe(getPublicKey(sk))
+    expect(decodedResult.tags).toStrictEqual([
+      ['u', 'http://test.com'],
+      ['method', 'post'],
+      ['payload', payloadHash],
+    ])
   })
 })
 
 describe('validateToken', () => {
   test('validateToken returns true for valid token without authorization scheme', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk))
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk))
 
     const result = await validateToken(validToken, 'http://test.com', 'get')
     expect(result).toBe(true)
   })
 
   test('validateToken returns true for valid token with authorization scheme', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk), true)
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk), true)
 
     const result = await validateToken(validToken, 'http://test.com', 'get')
     expect(result).toBe(true)
@@ -82,30 +95,30 @@ describe('validateToken', () => {
 
   test('validateToken throws an error for invalid token', async () => {
     const result = validateToken('fake', 'http://test.com', 'get')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
   })
 
   test('validateToken throws an error for missing token', async () => {
     const result = validateToken('', 'http://test.com', 'get')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
   })
 
   test('validateToken throws an error for a wrong url', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk))
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk))
 
     const result = validateToken(validToken, 'http://wrong-test.com', 'get')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
   })
 
   test('validateToken throws an error for a wrong method', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk))
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk))
 
     const result = validateToken(validToken, 'http://test.com', 'post')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
   })
 
   test('validateEvent returns true for valid decoded token with authorization scheme', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk), true)
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk), true)
     const decodedResult: Event = await unpackEventFromToken(validToken)
 
     const result = await validateEvent(decodedResult, 'http://test.com', 'get')
@@ -113,18 +126,34 @@ describe('validateToken', () => {
   })
 
   test('validateEvent throws an error for a wrong url', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk), true)
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk), true)
     const decodedResult: Event = await unpackEventFromToken(validToken)
 
     const result = validateEvent(decodedResult, 'http://wrong-test.com', 'get')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
   })
 
   test('validateEvent throws an error for a wrong method', async () => {
-    const validToken = await getToken('http://test.com', 'get', e => finishEvent(e, sk), true)
+    const validToken = await getToken('http://test.com', 'get', e => finalizeEvent(e, sk), true)
     const decodedResult: Event = await unpackEventFromToken(validToken)
 
     const result = validateEvent(decodedResult, 'http://test.com', 'post')
-    await expect(result).rejects.toThrow(Error)
+    expect(result).rejects.toThrow(Error)
+  })
+
+  test('validateEvent returns true for valid payload tag hash', async () => {
+    const validToken = await getToken('http://test.com', 'post', e => finalizeEvent(e, sk), true, { test: 'payload' })
+    const decodedResult: Event = await unpackEventFromToken(validToken)
+
+    const result = await validateEvent(decodedResult, 'http://test.com', 'post', { test: 'payload' })
+    expect(result).toBe(true)
+  })
+
+  test('validateEvent returns false for invalid payload tag hash', async () => {
+    const validToken = await getToken('http://test.com', 'post', e => finalizeEvent(e, sk), true, { test: 'a-payload' })
+    const decodedResult: Event = await unpackEventFromToken(validToken)
+
+    const result = validateEvent(decodedResult, 'http://test.com', 'post', { test: 'a-different-payload' })
+    expect(result).rejects.toThrow(Error)
   })
 })

nip98.ts

@@ -1,9 +1,17 @@
+import { bytesToHex } from '@noble/hashes/utils'
+import { sha256 } from '@noble/hashes/sha256'
 import { base64 } from '@scure/base'
-import { Event, EventTemplate, Kind, getBlankEvent, verifySignature } from './event'
-import { utf8Decoder, utf8Encoder } from './utils'
+import { Event, EventTemplate, verifyEvent } from './pure.ts'
+import { utf8Decoder, utf8Encoder } from './utils.ts'
+import { HTTPAuth } from './kinds.ts'
 
 const _authorizationScheme = 'Nostr '
 
+export function hashPayload(payload: any): string {
+  const hash = sha256(utf8Encoder.encode(JSON.stringify(payload)))
+  return bytesToHex(hash)
+}
+
 /**
  * Generate token for NIP-98 flow.
  *
@@ -14,22 +22,27 @@ const _authorizationScheme = 'Nostr '
 export async function getToken(
   loginUrl: string,
   httpMethod: string,
-  sign: <K extends number = number>(e: EventTemplate<K>) => Promise<Event<K>> | Event<K>,
+  sign: (e: EventTemplate) => Promise<Event> | Event,
   includeAuthorizationScheme: boolean = false,
+  payload?: Record<string, any>,
 ): Promise<string> {
-  if (!loginUrl || !httpMethod) throw new Error('Missing loginUrl or httpMethod')
+  const event: EventTemplate = {
+    kind: HTTPAuth,
+    tags: [
+      ['u', loginUrl],
+      ['method', httpMethod],
+    ],
+    created_at: Math.round(new Date().getTime() / 1000),
+    content: '',
+  }
 
-  const event = getBlankEvent(Kind.HttpAuth)
-
-  event.tags = [
-    ['u', loginUrl],
-    ['method', httpMethod],
-  ]
-  event.created_at = Math.round(new Date().getTime() / 1000)
+  if (payload) {
+    event.tags.push(['payload', bytesToHex(sha256(utf8Encoder.encode(JSON.stringify(payload))))])
+  }
 
   const signedEvent = await sign(event)
-
   const authorizationScheme = includeAuthorizationScheme ? _authorizationScheme : ''
+
   return authorizationScheme + base64.encode(utf8Encoder.encode(JSON.stringify(signedEvent)))
 }
 
@@ -66,14 +79,14 @@ export async function unpackEventFromToken(token: string): Promise<Event> {
   return event
 }
 
-export async function validateEvent(event: Event, url: string, method: string): Promise<boolean> {
+export async function validateEvent(event: Event, url: string, method: string, body?: any): Promise<boolean> {
   if (!event) {
     throw new Error('Invalid nostr event')
   }
-  if (!verifySignature(event)) {
+  if (!verifyEvent(event)) {
     throw new Error('Invalid nostr event, signature invalid')
   }
-  if (event.kind !== Kind.HttpAuth) {
+  if (event.kind !== HTTPAuth) {
     throw new Error('Invalid nostr event, kind invalid')
   }
 
@@ -96,5 +109,13 @@ export async function validateEvent(event: Event, url: string, method: string):
     throw new Error('Invalid nostr event, method tag invalid')
   }
 
+  if (Boolean(body) && Object.keys(body).length > 0) {
+    const payloadTag = event.tags.find(t => t[0] === 'payload')
+    const payloadHash = bytesToHex(sha256(utf8Encoder.encode(JSON.stringify(body))))
+    if (payloadTag?.[1] !== payloadHash) {
+      throw new Error('Invalid payload tag hash, does not match request body hash')
+    }
+  }
+
   return true
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-tools",
-  "version": "1.17.0",
+  "version": "2.0.1",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -19,26 +19,26 @@
       "require": "./lib/cjs/index.js",
       "types": "./lib/types/index.d.ts"
     },
-    "./keys": {
-      "import": "./lib/esm/keys.js",
-      "require": "./lib/cjs/keys.js",
-      "types": "./lib/types/keys.d.ts"
+    "./pure": {
+      "import": "./lib/esm/pure.js",
+      "require": "./lib/cjs/pure.js",
+      "types": "./lib/types/pure.d.ts"
     },
-    "./relay": {
-      "import": "./lib/esm/relay.js",
-      "require": "./lib/cjs/relay.js",
-      "types": "./lib/types/relay.d.ts"
-    },
-    "./event": {
-      "import": "./lib/esm/event.js",
-      "require": "./lib/cjs/event.js",
-      "types": "./lib/types/event.d.ts"
+    "./wasm": {
+      "import": "./lib/esm/wasm.js",
+      "require": "./lib/cjs/wasm.js",
+      "types": "./lib/types/wasm.d.ts"
     },
     "./filter": {
       "import": "./lib/esm/filter.js",
       "require": "./lib/cjs/filter.js",
       "types": "./lib/types/filter.d.ts"
     },
+    "./relay": {
+      "import": "./lib/esm/relay.js",
+      "require": "./lib/cjs/relay.js",
+      "types": "./lib/types/relay.d.ts"
+    },
     "./pool": {
       "import": "./lib/esm/pool.js",
       "require": "./lib/cjs/pool.js",
@@ -69,6 +69,11 @@
       "require": "./lib/cjs/nip10.js",
       "types": "./lib/types/nip10.d.ts"
     },
+    "./nip11": {
+      "import": "./lib/esm/nip11.js",
+      "require": "./lib/cjs/nip11.js",
+      "types": "./lib/types/nip11.d.ts"
+    },
     "./nip13": {
       "import": "./lib/esm/nip13.js",
       "require": "./lib/cjs/nip13.js",
@@ -94,11 +99,6 @@
       "require": "./lib/cjs/nip25.js",
       "types": "./lib/types/nip25.d.ts"
     },
-    "./nip26": {
-      "import": "./lib/esm/nip26.js",
-      "require": "./lib/cjs/nip26.js",
-      "types": "./lib/types/nip26.d.ts"
-    },
     "./nip27": {
       "import": "./lib/esm/nip27.js",
       "require": "./lib/cjs/nip27.js",
@@ -109,6 +109,11 @@
       "require": "./lib/cjs/nip28.js",
       "types": "./lib/types/nip28.d.ts"
     },
+    "./nip30": {
+      "import": "./lib/esm/nip30.js",
+      "require": "./lib/cjs/nip30.js",
+      "types": "./lib/types/nip30.d.ts"
+    },
     "./nip39": {
       "import": "./lib/esm/nip39.js",
       "require": "./lib/cjs/nip39.js",
@@ -119,11 +124,6 @@
       "require": "./lib/cjs/nip42.js",
       "types": "./lib/types/nip42.d.ts"
     },
-    "./nip44": {
-      "import": "./lib/esm/nip44.js",
-      "require": "./lib/cjs/nip44.js",
-      "types": "./lib/types/nip44.d.ts"
-    },
     "./nip57": {
       "import": "./lib/esm/nip57.js",
       "require": "./lib/cjs/nip57.js",
@@ -148,11 +148,12 @@
   "license": "Unlicense",
   "dependencies": {
     "@noble/ciphers": "0.2.0",
-    "@noble/curves": "1.1.0",
+    "@noble/curves": "1.2.0",
     "@noble/hashes": "1.3.1",
     "@scure/base": "1.1.1",
     "@scure/bip32": "1.3.1",
-    "@scure/bip39": "1.2.1"
+    "@scure/bip39": "1.2.1",
+    "nostr-wasm": "v0.0.3"
   },
   "peerDependencies": {
     "typescript": ">=5.0.0"
@@ -169,31 +170,25 @@
     "client",
     "nostr"
   ],
-  "scripts": {
-    "build": "node build && tsc",
-    "format": "prettier --plugin-search-dir . --write .",
-    "test": "jest"
-  },
   "devDependencies": {
-    "@types/jest": "^29.5.1",
     "@types/node": "^18.13.0",
     "@types/node-fetch": "^2.6.3",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
+    "bun-types": "^1.0.18",
     "esbuild": "0.16.9",
     "esbuild-plugin-alias": "^0.2.1",
-    "eslint": "^8.48.0",
+    "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-babel": "^5.3.1",
-    "eslint-plugin-jest": "^27.2.3",
     "esm-loader-typescript": "^1.0.3",
     "events": "^3.3.0",
-    "jest": "^29.5.0",
     "node-fetch": "^2.6.9",
     "prettier": "^3.0.3",
-    "ts-jest": "^29.1.0",
     "tsd": "^0.22.0",
-    "typescript": "^5.0.4",
-    "websocket-polyfill": "^0.0.3"
+    "typescript": "^5.0.4"
+  },
+  "scripts": {
+    "prepublish": "just build && just emit-types"
   }
 }

pool.test.ts

@@ -1,38 +1,32 @@
-import 'websocket-polyfill'
+import { test, expect, afterAll } from 'bun:test'
 
-import { finishEvent, type Event } from './event.ts'
-import { generatePrivateKey, getPublicKey } from './keys.ts'
+import { finalizeEvent, type Event } from './pure.ts'
+import { generateSecretKey, getPublicKey } from './pure.ts'
 import { SimplePool } from './pool.ts'
 
 let pool = new SimplePool()
 
-let relays = [
-  'wss://relay.damus.io/',
-  'wss://relay.nostr.bg/',
-  'wss://nostr.fmt.wiz.biz/',
-  'wss://relay.nostr.band/',
-  'wss://nos.lol/',
-]
+let relays = ['wss://relay.damus.io/', 'wss://relay.nostr.bg/', 'wss://nos.lol', 'wss://public.relaying.io']
 
 afterAll(() => {
-  pool.close([...relays, 'wss://nostr.wine', 'wss://offchain.pub', 'wss://eden.nostr.land'])
+  pool.close([...relays, 'wss://offchain.pub', 'wss://eden.nostr.land'])
 })
 
 test('removing duplicates when querying', async () => {
-  let priv = generatePrivateKey()
+  let priv = generateSecretKey()
   let pub = getPublicKey(priv)
 
-  let sub = pool.sub(relays, [{ authors: [pub] }])
+  pool.subscribeMany(relays, [{ authors: [pub] }], {
+    onevent(event: Event) {
+      // this should be called only once even though we're listening
+      // to multiple relays because the events will be catched and
+      // deduplicated efficiently (without even being parsed)
+      received.push(event)
+    },
+  })
   let received: Event[] = []
 
-  sub.on('event', event => {
-    // this should be called only once even though we're listening
-    // to multiple relays because the events will be catched and
-    // deduplicated efficiently (without even being parsed)
-    received.push(event)
-  })
-
-  let event = finishEvent(
+  let event = finalizeEvent(
     {
       created_at: Math.round(Date.now() / 1000),
       content: 'test',
@@ -42,31 +36,31 @@ test('removing duplicates when querying', async () => {
     priv,
   )
 
-  pool.publish(relays, event)
-
+  await Promise.any(pool.publish(relays, event))
   await new Promise(resolve => setTimeout(resolve, 1500))
 
   expect(received).toHaveLength(1)
+  expect(received[0]).toEqual(event)
 })
 
 test('same with double querying', async () => {
-  let priv = generatePrivateKey()
+  let priv = generateSecretKey()
   let pub = getPublicKey(priv)
 
-  let sub1 = pool.sub(relays, [{ authors: [pub] }])
-  let sub2 = pool.sub(relays, [{ authors: [pub] }])
+  pool.subscribeMany(relays, [{ authors: [pub] }], {
+    onevent(event) {
+      received.push(event)
+    },
+  })
+  pool.subscribeMany(relays, [{ authors: [pub] }], {
+    onevent(event) {
+      received.push(event)
+    },
+  })
 
   let received: Event[] = []
 
-  sub1.on('event', event => {
-    received.push(event)
-  })
-
-  sub2.on('event', event => {
-    received.push(event)
-  })
-
-  let event = finishEvent(
+  let event = finalizeEvent(
     {
       created_at: Math.round(Date.now() / 1000),
       content: 'test2',
@@ -76,55 +70,30 @@ test('same with double querying', async () => {
     priv,
   )
 
-  pool.publish(relays, event)
-
+  await Promise.any(pool.publish(relays, event))
   await new Promise(resolve => setTimeout(resolve, 1500))
 
   expect(received).toHaveLength(2)
 })
 
-test('get()', async () => {
-  let event = await pool.get(relays, {
-    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
+test('querySync()', async () => {
+  let events = await pool.querySync([...relays.slice(2), 'wss://offchain.pub', 'wss://eden.nostr.land'], {
+    authors: ['3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'],
+    kinds: [1],
+    limit: 2,
   })
 
-  expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-})
-
-test('list()', async () => {
-  let events = await pool.list(
-    [...relays, 'wss://offchain.pub', 'wss://eden.nostr.land'],
-    [
-      {
-        authors: ['3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'],
-        kinds: [1],
-        limit: 2,
-      },
-    ],
-  )
-
   // the actual received number will be greater than 2, but there will be no duplicates
-  expect(events.length).toEqual(
-    events
-      .map(evt => evt.id)
-      // @ts-ignore ???
-      .reduce((acc, n) => (acc.indexOf(n) !== -1 ? acc : [...acc, n]), []).length,
-  )
-
-  let relaysForAllEvents = events.map(event => pool.seenOn(event.id)).reduce((acc, n) => acc.concat(n), [])
-  expect(relaysForAllEvents.length).toBeGreaterThanOrEqual(events.length)
+  expect(events.length).toBeGreaterThan(2)
+  const uniqueEventCount = new Set(events.map(evt => evt.id)).size
+  expect(events).toHaveLength(uniqueEventCount)
 })
 
-test('seenOnEnabled: false', async () => {
-  const poolWithoutSeenOn = new SimplePool({ seenOnEnabled: false })
-
-  const event = await poolWithoutSeenOn.get(relays, {
-    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
+test('get()', async () => {
+  let event = await pool.get(relays, {
+    ids: ['9fa1c618fcaad6357e074417b07ed132b083ed30e13113ebb10fcda7137442fe'],
   })
 
-  expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-
-  const relaysForEvent = poolWithoutSeenOn.seenOn(event!.id)
-
-  expect(relaysForEvent).toHaveLength(0)
+  expect(event).not.toBeNull()
+  expect(event).toHaveProperty('id', '9fa1c618fcaad6357e074417b07ed132b083ed30e13113ebb10fcda7137442fe')
 })

pool.ts

@@ -1,249 +1,183 @@
-import { eventsGenerator, relayInit, type Relay, type Sub, type SubscriptionOptions } from './relay.ts'
+import { Relay, SubscriptionParams, Subscription } from './relay.ts'
 import { normalizeURL } from './utils.ts'
 
-import type { Event } from './event.ts'
-import { matchFilters, mergeFilters, type Filter } from './filter.ts'
+import type { Event } from './pure.ts'
+import { type Filter } from './filter.ts'
 
-type BatchedRequest = {
-  filters: Filter<any>[]
-  relays: string[]
-  resolve: (events: Event<any>[]) => void
-  events: Event<any>[]
+export type SubCloser = { close: () => void }
+
+export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose' | 'id'> & {
+  maxWait?: number
+  onclose?: (reasons: string[]) => void
+  id?: string
 }
 
 export class SimplePool {
-  private _conn: { [url: string]: Relay }
-  private _seenOn: { [id: string]: Set<string> } = {} // a map of all events we've seen in each relay
-  private batchedByKey: { [batchKey: string]: BatchedRequest[] } = {}
+  private relays = new Map<string, Relay>()
+  public seenOn = new Map<string, Set<Relay>>()
+  public trackRelays: boolean = false
 
-  private eoseSubTimeout: number
-  private getTimeout: number
-  private seenOnEnabled: boolean = true
-  private batchInterval: number = 100
+  public trustedRelayURLs = new Set<string>()
 
-  constructor(
-    options: {
-      eoseSubTimeout?: number
-      getTimeout?: number
-      seenOnEnabled?: boolean
-      batchInterval?: number
-    } = {},
-  ) {
-    this._conn = {}
-    this.eoseSubTimeout = options.eoseSubTimeout || 3400
-    this.getTimeout = options.getTimeout || 3400
-    this.seenOnEnabled = options.seenOnEnabled !== false
-    this.batchInterval = options.batchInterval || 100
-  }
+  async ensureRelay(url: string, params?: { connectionTimeout?: number }): Promise<Relay> {
+    url = normalizeURL(url)
 
-  close(relays: string[]): void {
-    relays.forEach(url => {
-      let relay = this._conn[normalizeURL(url)]
-      if (relay) relay.close()
-    })
-  }
-
-  async ensureRelay(url: string): Promise<Relay> {
-    const nm = normalizeURL(url)
-
-    if (!this._conn[nm]) {
-      this._conn[nm] = relayInit(nm, {
-        getTimeout: this.getTimeout * 0.9,
-        listTimeout: this.getTimeout * 0.9,
-      })
+    let relay = this.relays.get(url)
+    if (!relay) {
+      relay = new Relay(url)
+      if (params?.connectionTimeout) relay.connectionTimeout = params.connectionTimeout
+      if (this.trustedRelayURLs.has(relay.url)) relay.trusted = true
+      this.relays.set(url, relay)
+      await relay.connect()
     }
 
-    const relay = this._conn[nm]
-    await relay.connect()
     return relay
   }
 
-  sub<K extends number = number>(relays: string[], filters: Filter<K>[], opts?: SubscriptionOptions): Sub<K> {
-    let _knownIds: Set<string> = new Set()
-    let modifiedOpts = { ...(opts || {}) }
-    modifiedOpts.alreadyHaveEvent = (id, url) => {
-      if (opts?.alreadyHaveEvent?.(id, url)) {
+  close(relays: string[]) {
+    relays.map(normalizeURL).forEach(url => {
+      this.relays.get(url)?.close()
+    })
+  }
+
+  subscribeMany(relays: string[], filters: Filter[], params: SubscribeManyParams): SubCloser {
+    if (this.trackRelays) {
+      params.receivedEvent = (relay: Relay, id: string) => {
+        let set = this.seenOn.get(id)
+        if (!set) {
+          set = new Set()
+          this.seenOn.set(id, set)
+        }
+        set.add(relay)
+      }
+    }
+
+    const _knownIds = new Set<string>()
+    const subs: Subscription[] = []
+
+    // batch all EOSEs into a single
+    const eosesReceived: boolean[] = []
+    let handleEose = (i: number) => {
+      eosesReceived[i] = true
+      if (eosesReceived.filter(a => a).length === relays.length) {
+        params.oneose?.()
+        handleEose = () => {}
+      }
+    }
+    // batch all closes into a single
+    const closesReceived: string[] = []
+    let handleClose = (i: number, reason: string) => {
+      handleEose(i)
+      closesReceived[i] = reason
+      if (closesReceived.filter(a => a).length === relays.length) {
+        params.onclose?.(closesReceived)
+        handleClose = () => {}
+      }
+    }
+
+    const localAlreadyHaveEventHandler = (id: string) => {
+      if (params.alreadyHaveEvent?.(id)) {
         return true
       }
-      if (this.seenOnEnabled) {
-        let set = this._seenOn[id] || new Set()
-        set.add(url)
-        this._seenOn[id] = set
-      }
-      return _knownIds.has(id)
+      const have = _knownIds.has(id)
+      _knownIds.add(id)
+      return have
     }
 
-    let subs: Sub[] = []
-    let eventListeners: Set<any> = new Set()
-    let eoseListeners: Set<() => void> = new Set()
-    let eosesMissing = relays.length
-
-    let eoseSent = false
-    let eoseTimeout = setTimeout(
-      () => {
-        eoseSent = true
-        for (let cb of eoseListeners.values()) cb()
-      },
-      opts?.eoseSubTimeout || this.eoseSubTimeout,
-    )
-
-    relays
-      .filter((r, i, a) => a.indexOf(r) === i)
-      .forEach(async relay => {
-        let r
-        try {
-          r = await this.ensureRelay(relay)
-        } catch (err) {
-          handleEose()
+    // open a subscription in all given relays
+    const allOpened = Promise.all(
+      relays.map(normalizeURL).map(async (url, i, arr) => {
+        if (arr.indexOf(url) !== i) {
+          // duplicate
+          handleClose(i, 'duplicate url')
           return
         }
-        if (!r) return
-        let s = r.sub(filters, modifiedOpts)
-        s.on('event', event => {
-          _knownIds.add(event.id as string)
-          for (let cb of eventListeners.values()) cb(event)
-        })
-        s.on('eose', () => {
-          if (eoseSent) return
-          handleEose()
-        })
-        subs.push(s)
 
-        function handleEose() {
-          eosesMissing--
-          if (eosesMissing === 0) {
-            clearTimeout(eoseTimeout)
-            for (let cb of eoseListeners.values()) cb()
-          }
+        let relay: Relay
+        try {
+          relay = await this.ensureRelay(url, {
+            connectionTimeout: params.maxWait ? Math.max(params.maxWait * 0.8, params.maxWait - 1000) : undefined,
+          })
+        } catch (err) {
+          handleClose(i, (err as any)?.message || String(err))
+          return
         }
-      })
 
-    let greaterSub: Sub<K> = {
-      sub(filters, opts) {
-        subs.forEach(sub => sub.sub(filters, opts))
-        return greaterSub as any
-      },
-      unsub() {
-        subs.forEach(sub => sub.unsub())
-      },
-      on(type, cb) {
-        if (type === 'event') {
-          eventListeners.add(cb)
-        } else if (type === 'eose') {
-          eoseListeners.add(cb as () => void | Promise<void>)
-        }
-      },
-      off(type, cb) {
-        if (type === 'event') {
-          eventListeners.delete(cb)
-        } else if (type === 'eose') eoseListeners.delete(cb as () => void | Promise<void>)
-      },
-      get events() {
-        return eventsGenerator(greaterSub)
+        let subscription = relay.subscribe(filters, {
+          ...params,
+          oneose: () => handleEose(i),
+          onclose: reason => handleClose(i, reason),
+          alreadyHaveEvent: localAlreadyHaveEventHandler,
+          eoseTimeout: params.maxWait,
+        })
+
+        subs.push(subscription)
+      }),
+    )
+
+    return {
+      async close() {
+        await allOpened
+        subs.forEach(sub => {
+          sub.close()
+        })
       },
     }
-
-    return greaterSub
   }
 
-  get<K extends number = number>(
+  subscribeManyEose(
     relays: string[],
-    filter: Filter<K>,
-    opts?: SubscriptionOptions,
-  ): Promise<Event<K> | null> {
-    return new Promise(resolve => {
-      let sub = this.sub(relays, [filter], opts)
-      let timeout = setTimeout(() => {
-        sub.unsub()
-        resolve(null)
-      }, this.getTimeout)
-      sub.on('event', event => {
-        resolve(event)
-        clearTimeout(timeout)
-        sub.unsub()
+    filters: Filter[],
+    params: Pick<SubscribeManyParams, 'id' | 'onevent' | 'onclose' | 'maxWait'>,
+  ): SubCloser {
+    const subcloser = this.subscribeMany(relays, filters, {
+      ...params,
+      oneose() {
+        subcloser.close()
+      },
+    })
+    return subcloser
+  }
+
+  async querySync(
+    relays: string[],
+    filter: Filter,
+    params?: Pick<SubscribeManyParams, 'id' | 'maxWait'>,
+  ): Promise<Event[]> {
+    return new Promise(async resolve => {
+      const events: Event[] = []
+      this.subscribeManyEose(relays, [filter], {
+        ...params,
+        onevent(event: Event) {
+          events.push(event)
+        },
+        onclose(_: string[]) {
+          resolve(events)
+        },
       })
     })
   }
 
-  list<K extends number = number>(
+  async get(
     relays: string[],
-    filters: Filter<K>[],
-    opts?: SubscriptionOptions,
-  ): Promise<Event<K>[]> {
-    return new Promise(resolve => {
-      let events: Event<K>[] = []
-      let sub = this.sub(relays, filters, opts)
-
-      sub.on('event', event => {
-        events.push(event)
-      })
-
-      // we can rely on an eose being emitted here because pool.sub() will fake one
-      sub.on('eose', () => {
-        sub.unsub()
-        resolve(events)
-      })
-    })
+    filter: Filter,
+    params?: Pick<SubscribeManyParams, 'id' | 'maxWait'>,
+  ): Promise<Event | null> {
+    filter.limit = 1
+    const events = await this.querySync(relays, filter, params)
+    events.sort((a, b) => b.created_at - a.created_at)
+    return events[0] || null
   }
 
-  batchedList<K extends number = number>(
-    batchKey: string,
-    relays: string[],
-    filters: Filter<K>[],
-  ): Promise<Event<K>[]> {
-    return new Promise(resolve => {
-      if (!this.batchedByKey[batchKey]) {
-        this.batchedByKey[batchKey] = [
-          {
-            filters,
-            relays,
-            resolve,
-            events: [],
-          },
-        ]
-
-        setTimeout(() => {
-          Object.keys(this.batchedByKey).forEach(async batchKey => {
-            const batchedRequests = this.batchedByKey[batchKey]
-
-            const filters = [] as Filter[]
-            const relays = [] as string[]
-            batchedRequests.forEach(br => {
-              filters.push(...br.filters)
-              relays.push(...br.relays)
-            })
-
-            const sub = this.sub(relays, [mergeFilters(...filters)])
-            sub.on('event', event => {
-              batchedRequests.forEach(br => matchFilters(br.filters, event) && br.events.push(event))
-            })
-            sub.on('eose', () => {
-              sub.unsub()
-              batchedRequests.forEach(br => br.resolve(br.events))
-            })
-
-            delete this.batchedByKey[batchKey]
-          })
-        }, this.batchInterval)
-      } else {
-        this.batchedByKey[batchKey].push({
-          filters,
-          relays,
-          resolve,
-          events: [],
-        })
+  publish(relays: string[], event: Event): Promise<string>[] {
+    return relays.map(normalizeURL).map(async (url, i, arr) => {
+      if (arr.indexOf(url) !== i) {
+        // duplicate
+        return Promise.reject('duplicate url')
       }
-    })
-  }
 
-  publish(relays: string[], event: Event<number>): Promise<void>[] {
-    return relays.map(async relay => {
-      let r = await this.ensureRelay(relay)
+      let r = await this.ensureRelay(url)
       return r.publish(event)
     })
   }
-
-  seenOn(id: string): string[] {
-    return Array.from(this._seenOn[id]?.values?.() || [])
-  }
 }

pure.ts

@@ -0,0 +1,59 @@
+import { schnorr } from '@noble/curves/secp256k1'
+import { bytesToHex } from '@noble/hashes/utils'
+import { Nostr, Event, EventTemplate, UnsignedEvent, VerifiedEvent, verifiedSymbol, validateEvent } from './core'
+import { sha256 } from '@noble/hashes/sha256'
+
+import { utf8Encoder } from './utils.ts'
+
+class JS implements Nostr {
+  generateSecretKey(): Uint8Array {
+    return schnorr.utils.randomPrivateKey()
+  }
+  getPublicKey(secretKey: Uint8Array): string {
+    return bytesToHex(schnorr.getPublicKey(secretKey))
+  }
+  finalizeEvent(t: EventTemplate, secretKey: Uint8Array): VerifiedEvent {
+    const event = t as VerifiedEvent
+    event.pubkey = bytesToHex(schnorr.getPublicKey(secretKey))
+    event.id = getEventHash(event)
+    event.sig = bytesToHex(schnorr.sign(getEventHash(event), secretKey))
+    event[verifiedSymbol] = true
+    return event
+  }
+  verifyEvent(event: Event): event is VerifiedEvent {
+    if (typeof event[verifiedSymbol] === 'boolean') return event[verifiedSymbol]
+
+    const hash = getEventHash(event)
+    if (hash !== event.id) {
+      event[verifiedSymbol] = false
+      return false
+    }
+
+    try {
+      const valid = schnorr.verify(event.sig, hash, event.pubkey)
+      event[verifiedSymbol] = valid
+      return valid
+    } catch (err) {
+      event[verifiedSymbol] = false
+      return false
+    }
+  }
+}
+
+export function serializeEvent(evt: UnsignedEvent): string {
+  if (!validateEvent(evt)) throw new Error("can't serialize event with wrong or missing properties")
+  return JSON.stringify([0, evt.pubkey, evt.created_at, evt.kind, evt.tags, evt.content])
+}
+
+export function getEventHash(event: UnsignedEvent): string {
+  let eventHash = sha256(utf8Encoder.encode(serializeEvent(event)))
+  return bytesToHex(eventHash)
+}
+
+const i = new JS()
+
+export const generateSecretKey = i.generateSecretKey
+export const getPublicKey = i.getPublicKey
+export const finalizeEvent = i.finalizeEvent
+export const verifyEvent = i.verifyEvent
+export * from './core.ts'

references.test.ts

@@ -1,3 +1,4 @@
+import { test, expect } from 'bun:test'
 import { parseReferences } from './references.ts'
 import { buildEvent } from './test-helpers.ts'
 

references.ts

@@ -1,6 +1,6 @@
 import { decode, type AddressPointer, type ProfilePointer, type EventPointer } from './nip19.ts'
 
-import type { Event } from './event.ts'
+import type { Event } from './pure.ts'
 
 type Reference = {
   text: string

relay.test.ts

@@ -1,124 +1,99 @@
-import 'websocket-polyfill'
+import { test, expect, afterEach, beforeEach } from 'bun:test'
 
-import { finishEvent } from './event.ts'
-import { generatePrivateKey, getPublicKey } from './keys.ts'
-import { relayInit } from './relay.ts'
+import { finalizeEvent } from './pure.ts'
+import { generateSecretKey, getPublicKey } from './pure.ts'
+import { Relay } from './relay.ts'
 
-let relay = relayInit('wss://relay.damus.io/')
+let relay = new Relay('wss://public.relaying.io')
 
-beforeAll(() => {
+beforeEach(() => {
   relay.connect()
 })
 
-afterAll(() => {
+afterEach(() => {
   relay.close()
 })
 
-test('connectivity', () => {
-  return expect(
-    new Promise(resolve => {
-      relay.on('connect', () => {
-        resolve(true)
-      })
-      relay.on('error', () => {
-        resolve(false)
-      })
-    }),
-  ).resolves.toBe(true)
+test('connectivity', async () => {
+  await relay.connect()
+  expect(relay.connected).toBeTrue()
 })
 
 test('querying', async () => {
-  var resolve1: (value: boolean) => void
-  var resolve2: (value: boolean) => void
+  let resolve1: () => void
+  let resolve2: () => void
 
-  let sub = relay.sub([
-    {
-      ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-    },
-  ])
-  sub.on('event', event => {
-    expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-    resolve1(true)
-  })
-  sub.on('eose', () => {
-    resolve2(true)
-  })
-
-  let [t1, t2] = await Promise.all([
-    new Promise<boolean>(resolve => {
+  let waiting = Promise.all([
+    new Promise<void>(resolve => {
       resolve1 = resolve
     }),
-    new Promise<boolean>(resolve => {
+    new Promise<void>(resolve => {
       resolve2 = resolve
     }),
   ])
 
-  expect(t1).toEqual(true)
-  expect(t2).toEqual(true)
+  relay.subscribe(
+    [
+      {
+        ids: ['3abc6cbb215af0412ab2c9c8895d96a084297890fd0b4018f8427453350ca2e4'],
+      },
+    ],
+    {
+      onevent(event) {
+        expect(event).toHaveProperty('id', '3abc6cbb215af0412ab2c9c8895d96a084297890fd0b4018f8427453350ca2e4')
+        expect(event).toHaveProperty('content', '+')
+        expect(event).toHaveProperty('kind', 7)
+        resolve1()
+      },
+      oneose() {
+        resolve2()
+      },
+    },
+  )
+
+  let [t1, t2] = await waiting
+  expect(t1).toBeUndefined()
+  expect(t2).toBeUndefined()
 }, 10000)
 
-test('async iterator', async () => {
-  let sub = relay.sub([
-    {
-      ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-    },
-  ])
-
-  for await (const event of sub.events) {
-    expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-    break
-  }
-})
-
-test('get()', async () => {
-  let event = await relay.get({
-    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-  })
-
-  expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-})
-
-test('list()', async () => {
-  let events = await relay.list([
-    {
-      authors: ['3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'],
-      kinds: [1],
-      limit: 2,
-    },
-  ])
-
-  expect(events.length).toEqual(2)
-})
-
-test('listening (twice) and publishing', async () => {
-  let sk = generatePrivateKey()
+test('listening and publishing and closing', async () => {
+  let sk = generateSecretKey()
   let pk = getPublicKey(sk)
-  var resolve1: (value: boolean) => void
-  var resolve2: (value: boolean) => void
+  var resolve1: (_: void) => void
+  var resolve2: (_: void) => void
 
-  let sub = relay.sub([
-    {
-      kinds: [27572],
-      authors: [pk],
-    },
+  let waiting = Promise.all([
+    new Promise(resolve => {
+      resolve1 = resolve
+    }),
+    new Promise(resolve => {
+      resolve2 = resolve
+    }),
   ])
 
-  sub.on('event', event => {
-    expect(event).toHaveProperty('pubkey', pk)
-    expect(event).toHaveProperty('kind', 27572)
-    expect(event).toHaveProperty('content', 'nostr-tools test suite')
-    resolve1(true)
-  })
-  sub.on('event', event => {
-    expect(event).toHaveProperty('pubkey', pk)
-    expect(event).toHaveProperty('kind', 27572)
-    expect(event).toHaveProperty('content', 'nostr-tools test suite')
-    resolve2(true)
-  })
-
-  let event = finishEvent(
+  let sub = relay.subscribe(
+    [
+      {
+        kinds: [23571],
+        authors: [pk],
+      },
+    ],
     {
-      kind: 27572,
+      onevent(event) {
+        expect(event).toHaveProperty('pubkey', pk)
+        expect(event).toHaveProperty('kind', 23571)
+        expect(event).toHaveProperty('content', 'nostr-tools test suite')
+        resolve1()
+      },
+      onclose() {
+        resolve2()
+      },
+    },
+  )
+
+  let event = finalizeEvent(
+    {
+      kind: 23571,
       created_at: Math.floor(Date.now() / 1000),
       tags: [],
       content: 'nostr-tools test suite',
@@ -126,15 +101,10 @@ test('listening (twice) and publishing', async () => {
     sk,
   )
 
-  relay.publish(event)
-  return expect(
-    Promise.all([
-      new Promise(resolve => {
-        resolve1 = resolve
-      }),
-      new Promise(resolve => {
-        resolve2 = resolve
-      }),
-    ]),
-  ).resolves.toEqual([true, true])
+  await relay.publish(event)
+  sub.close()
+
+  let [t1, t2] = await waiting
+  expect(t1).toBeUndefined()
+  expect(t2).toBeUndefined()
 })

relay.ts

@@ -1,398 +1,351 @@
 /* global WebSocket */
 
-import { verifySignature, validateEvent, type Event } from './event.ts'
+import { verifyEvent, validateEvent, type Event, EventTemplate } from './pure.ts'
 import { matchFilters, type Filter } from './filter.ts'
 import { getHex64, getSubscriptionId } from './fakejson.ts'
-import { MessageQueue } from './utils.ts'
+import { Queue, normalizeURL } from './utils.ts'
+import { nip42 } from './index.ts'
+import { yieldThread } from './helpers.ts'
 
-type RelayEvent = {
-  connect: () => void | Promise<void>
-  disconnect: () => void | Promise<void>
-  error: () => void | Promise<void>
-  notice: (msg: string) => void | Promise<void>
-  auth: (challenge: string) => void | Promise<void>
-}
-export type CountPayload = {
-  count: number
-}
-export type SubEvent<K extends number> = {
-  event: (event: Event<K>) => void | Promise<void>
-  count: (payload: CountPayload) => void | Promise<void>
-  eose: () => void | Promise<void>
-}
-export type Relay = {
-  url: string
-  status: number
-  connect: () => Promise<void>
-  close: () => void
-  sub: <K extends number = number>(filters: Filter<K>[], opts?: SubscriptionOptions) => Sub<K>
-  list: <K extends number = number>(filters: Filter<K>[], opts?: SubscriptionOptions) => Promise<Event<K>[]>
-  get: <K extends number = number>(filter: Filter<K>, opts?: SubscriptionOptions) => Promise<Event<K> | null>
-  count: (filters: Filter[], opts?: SubscriptionOptions) => Promise<CountPayload | null>
-  publish: (event: Event<number>) => Promise<void>
-  auth: (event: Event<number>) => Promise<void>
-  off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(event: T, listener: U) => void
-  on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(event: T, listener: U) => void
-}
-export type Sub<K extends number = number> = {
-  sub: <K extends number = number>(filters: Filter<K>[], opts: SubscriptionOptions) => Sub<K>
-  unsub: () => void
-  on: <T extends keyof SubEvent<K>, U extends SubEvent<K>[T]>(event: T, listener: U) => void
-  off: <T extends keyof SubEvent<K>, U extends SubEvent<K>[T]>(event: T, listener: U) => void
-  events: AsyncGenerator<Event<K>, void, unknown>
+export function relayConnect(url: string) {
+  const relay = new Relay(url)
+  relay.connect()
+  return relay
 }
 
-export type SubscriptionOptions = {
-  id?: string
-  verb?: 'REQ' | 'COUNT'
-  skipVerification?: boolean
-  alreadyHaveEvent?: null | ((id: string, relay: string) => boolean)
-  eoseSubTimeout?: number
-}
+export class Relay {
+  public readonly url: string
+  private _connected: boolean = false
 
-const newListeners = (): { [TK in keyof RelayEvent]: RelayEvent[TK][] } => ({
-  connect: [],
-  disconnect: [],
-  error: [],
-  notice: [],
-  auth: [],
-})
+  public trusted: boolean = false
+  public onclose: (() => void) | null = null
+  public onnotice: (msg: string) => void = msg => console.debug(`NOTICE from ${this.url}: ${msg}`)
 
-export function relayInit(
-  url: string,
-  options: {
-    getTimeout?: number
-    listTimeout?: number
-    countTimeout?: number
-  } = {},
-): Relay {
-  let { listTimeout = 3000, getTimeout = 3000, countTimeout = 3000 } = options
+  public baseEoseTimeout: number = 4400
+  public connectionTimeout: number = 4400
+  private connectionTimeoutHandle: ReturnType<typeof setTimeout> | undefined
 
-  var ws: WebSocket
-  var openSubs: { [id: string]: { filters: Filter[] } & SubscriptionOptions } = {}
-  var listeners = newListeners()
-  var subListeners: {
-    [subid: string]: { [TK in keyof SubEvent<any>]: SubEvent<any>[TK][] }
-  } = {}
-  var pubListeners: {
-    [eventid: string]: {
-      resolve: (_: unknown) => void
-      reject: (err: Error) => void
+  private connectionPromise: Promise<void> | undefined
+  private openSubs = new Map<string, Subscription>()
+  private openCountRequests = new Map<string, CountResolver>()
+  private openEventPublishes = new Map<string, EventPublishResolver>()
+  private ws: WebSocket | undefined
+  private incomingMessageQueue = new Queue<string>()
+  private queueRunning = false
+  private challenge: string | undefined
+  private serial: number = 0
+
+  constructor(url: string) {
+    this.url = normalizeURL(url)
+  }
+
+  private closeAllSubscriptions(reason: string) {
+    for (let [_, sub] of this.openSubs) {
+      sub.close(reason)
     }
-  } = {}
+    this.openSubs.clear()
+
+    for (let [_, ep] of this.openEventPublishes) {
+      ep.reject(new Error(reason))
+    }
+    this.openEventPublishes.clear()
+
+    for (let [_, cr] of this.openCountRequests) {
+      cr.reject(new Error(reason))
+    }
+    this.openCountRequests.clear()
+  }
+
+  public get connected(): boolean {
+    return this._connected
+  }
+
+  public async connect(): Promise<void> {
+    if (this.connectionPromise) return this.connectionPromise
+
+    this.challenge = undefined
+    this.connectionPromise = new Promise((resolve, reject) => {
+      this.connectionTimeoutHandle = setTimeout(() => {
+        reject('connection timed out')
+        this.connectionPromise = undefined
+        this.onclose?.()
+        this.closeAllSubscriptions('relay connection timed out')
+      }, this.connectionTimeout)
 
-  var connectionPromise: Promise<void> | undefined
-  async function connectRelay(): Promise<void> {
-    if (connectionPromise) return connectionPromise
-    connectionPromise = new Promise((resolve, reject) => {
       try {
-        ws = new WebSocket(url)
+        this.ws = new WebSocket(this.url)
       } catch (err) {
         reject(err)
+        return
       }
 
-      ws.onopen = () => {
-        listeners.connect.forEach(cb => cb())
+      this.ws.onopen = () => {
+        clearTimeout(this.connectionTimeoutHandle)
+        this._connected = true
         resolve()
       }
-      ws.onerror = () => {
-        connectionPromise = undefined
-        listeners.error.forEach(cb => cb())
-        reject()
-      }
-      ws.onclose = async () => {
-        connectionPromise = undefined
-        listeners.disconnect.forEach(cb => cb())
-      }
 
-      let incomingMessageQueue: MessageQueue = new MessageQueue()
-      let handleNextInterval: any
-
-      ws.onmessage = e => {
-        incomingMessageQueue.enqueue(e.data)
-        if (!handleNextInterval) {
-          handleNextInterval = setInterval(handleNext, 0)
+      this.ws.onerror = ev => {
+        reject((ev as any).message)
+        if (this._connected) {
+          this.onclose?.()
+          this.closeAllSubscriptions('relay connection errored')
+          this._connected = false
         }
       }
 
-      function handleNext() {
-        if (incomingMessageQueue.size === 0) {
-          clearInterval(handleNextInterval)
-          handleNextInterval = null
-          return
-        }
+      this.ws.onclose = async () => {
+        this.connectionPromise = undefined
+        this.onclose?.()
+        this.closeAllSubscriptions('relay connection closed')
+        this._connected = false
+      }
 
-        var json = incomingMessageQueue.dequeue()
-        if (!json) return
-
-        let subid = getSubscriptionId(json)
-        if (subid) {
-          let so = openSubs[subid]
-          if (so && so.alreadyHaveEvent && so.alreadyHaveEvent(getHex64(json, 'id'), url)) {
-            return
-          }
-        }
-
-        try {
-          let data = JSON.parse(json)
-
-          // we won't do any checks against the data since all failures (i.e. invalid messages from relays)
-          // will naturally be caught by the encompassing try..catch block
-
-          switch (data[0]) {
-            case 'EVENT': {
-              let id = data[1]
-              let event = data[2]
-              if (
-                validateEvent(event) &&
-                openSubs[id] &&
-                (openSubs[id].skipVerification || verifySignature(event)) &&
-                matchFilters(openSubs[id].filters, event)
-              ) {
-                openSubs[id]
-                ;(subListeners[id]?.event || []).forEach(cb => cb(event))
-              }
-              return
-            }
-            case 'COUNT':
-              let id = data[1]
-              let payload = data[2]
-              if (openSubs[id]) {
-                ;(subListeners[id]?.count || []).forEach(cb => cb(payload))
-              }
-              return
-            case 'EOSE': {
-              let id = data[1]
-              if (id in subListeners) {
-                subListeners[id].eose.forEach(cb => cb())
-                subListeners[id].eose = [] // 'eose' only happens once per sub, so stop listeners here
-              }
-              return
-            }
-            case 'OK': {
-              let id: string = data[1]
-              let ok: boolean = data[2]
-              let reason: string = data[3] || ''
-              if (id in pubListeners) {
-                let { resolve, reject } = pubListeners[id]
-                if (ok) resolve(null)
-                else reject(new Error(reason))
-              }
-              return
-            }
-            case 'NOTICE':
-              let notice = data[1]
-              listeners.notice.forEach(cb => cb(notice))
-              return
-            case 'AUTH': {
-              let challenge = data[1]
-              listeners.auth?.forEach(cb => cb(challenge))
-              return
-            }
-          }
-        } catch (err) {
-          return
+      this.ws.onmessage = ev => {
+        this.incomingMessageQueue.enqueue(ev.data as string)
+        if (!this.queueRunning) {
+          this.runQueue()
         }
       }
     })
 
-    return connectionPromise
+    return this.connectionPromise
   }
 
-  function connected() {
-    return ws?.readyState === 1
+  private async runQueue() {
+    this.queueRunning = true
+    while (true) {
+      if (false === this.handleNext()) {
+        break
+      }
+      await yieldThread()
+    }
+    this.queueRunning = false
   }
 
-  async function connect(): Promise<void> {
-    if (connected()) return // ws already open
-    await connectRelay()
-  }
+  private handleNext(): undefined | false {
+    const json = this.incomingMessageQueue.dequeue()
+    if (!json) {
+      return false
+    }
 
-  async function trySend(params: [string, ...any]) {
-    let msg = JSON.stringify(params)
-    if (!connected()) {
-      await new Promise(resolve => setTimeout(resolve, 1000))
-      if (!connected()) {
+    const subid = getSubscriptionId(json)
+    if (subid) {
+      const so = this.openSubs.get(subid as string)
+      if (!so) {
+        // this is an EVENT message, but for a subscription we don't have, so just stop here
+        return
+      }
+
+      // this will be called only when this message is a EVENT message for a subscription we have
+      // we do this before parsing the JSON to not have to do that for duplicate events
+      //   since JSON parsing is slow
+      const id = getHex64(json, 'id')
+      const alreadyHave = so.alreadyHaveEvent?.(id)
+
+      // notify any interested client that the relay has this event
+      // (do this after alreadyHaveEvent() because the client may rely on this to answer that)
+      so.receivedEvent?.(this, id)
+
+      if (alreadyHave) {
+        // if we had already seen this event we can just stop here
         return
       }
     }
+
     try {
-      ws.send(msg)
+      let data = JSON.parse(json)
+      // we won't do any checks against the data since all failures (i.e. invalid messages from relays)
+      // will naturally be caught by the encompassing try..catch block
+
+      switch (data[0]) {
+        case 'EVENT': {
+          const so = this.openSubs.get(data[1] as string) as Subscription
+          const event = data[2] as Event
+          if ((this.trusted || (validateEvent(event) && verifyEvent(event))) && matchFilters(so.filters, event)) {
+            so.onevent(event)
+          }
+          return
+        }
+        case 'COUNT': {
+          const id: string = data[1]
+          const payload = data[2] as { count: number }
+          const cr = this.openCountRequests.get(id) as CountResolver
+          if (cr) {
+            cr.resolve(payload.count)
+            this.openCountRequests.delete(id)
+          }
+          return
+        }
+        case 'EOSE': {
+          const so = this.openSubs.get(data[1] as string)
+          if (!so) return
+          so.receivedEose()
+          return
+        }
+        case 'OK': {
+          const id: string = data[1]
+          const ok: boolean = data[2]
+          const reason: string = data[3]
+          const ep = this.openEventPublishes.get(id) as EventPublishResolver
+          if (ok) ep.resolve(reason)
+          else ep.reject(new Error(reason))
+          this.openEventPublishes.delete(id)
+          return
+        }
+        case 'CLOSED': {
+          const id: string = data[1]
+          const so = this.openSubs.get(id)
+          if (!so) return
+          so.closed = true
+          so.close(data[2] as string)
+          this.openSubs.delete(id)
+          return
+        }
+        case 'NOTICE':
+          this.onnotice(data[1] as string)
+          return
+        case 'AUTH': {
+          this.challenge = data[1] as string
+          return
+        }
+      }
     } catch (err) {
-      console.log(err)
+      return
     }
   }
 
-  const sub = <K extends number = number>(
-    filters: Filter<K>[],
-    {
-      verb = 'REQ',
-      skipVerification = false,
-      alreadyHaveEvent = null,
-      id = Math.random().toString().slice(2),
-    }: SubscriptionOptions = {},
-  ): Sub<K> => {
-    let subid = id
+  public async send(message: string) {
+    if (!this.connectionPromise) throw new Error('sending on closed connection')
 
-    openSubs[subid] = {
-      id: subid,
-      filters,
-      skipVerification,
-      alreadyHaveEvent,
-    }
-    trySend([verb, subid, ...filters])
+    this.connectionPromise.then(() => {
+      this.ws?.send(message)
+    })
+  }
 
-    let subscription: Sub<K> = {
-      sub: (newFilters, newOpts = {}) =>
-        sub(newFilters || filters, {
-          skipVerification: newOpts.skipVerification || skipVerification,
-          alreadyHaveEvent: newOpts.alreadyHaveEvent || alreadyHaveEvent,
-          id: subid,
-        }),
-      unsub: () => {
-        delete openSubs[subid]
-        delete subListeners[subid]
-        trySend(['CLOSE', subid])
-      },
-      on: (type, cb) => {
-        subListeners[subid] = subListeners[subid] || {
-          event: [],
-          count: [],
-          eose: [],
-        }
-        subListeners[subid][type].push(cb)
-      },
-      off: (type, cb): void => {
-        let listeners = subListeners[subid]
-        let idx = listeners[type].indexOf(cb)
-        if (idx >= 0) listeners[type].splice(idx, 1)
-      },
-      get events() {
-        return eventsGenerator(subscription)
-      },
-    }
+  public async auth(signAuthEvent: (authEvent: EventTemplate) => Promise<void>) {
+    if (!this.challenge) throw new Error("can't perform auth, no challenge was received")
+    const evt = nip42.makeAuthEvent(this.url, this.challenge)
+    await signAuthEvent(evt)
+    this.send('["AUTH",' + JSON.stringify(evt) + ']')
+  }
 
+  public async publish(event: Event): Promise<string> {
+    const ret = new Promise<string>((resolve, reject) => {
+      this.openEventPublishes.set(event.id, { resolve, reject })
+    })
+    this.send('["EVENT",' + JSON.stringify(event) + ']')
+    return ret
+  }
+
+  public async count(filters: Filter[], params: { id?: string | null }): Promise<number> {
+    this.serial++
+    const id = params?.id || 'count:' + this.serial
+    const ret = new Promise<number>((resolve, reject) => {
+      this.openCountRequests.set(id, { resolve, reject })
+    })
+    this.send('["COUNT","' + id + '",' + JSON.stringify(filters) + ']')
+    return ret
+  }
+
+  public subscribe(filters: Filter[], params: Partial<SubscriptionParams>): Subscription {
+    const subscription = this.prepareSubscription(filters, params)
+    subscription.fire()
     return subscription
   }
 
-  function _publishEvent(event: Event<number>, type: string) {
-    return new Promise((resolve, reject) => {
-      if (!event.id) {
-        reject(new Error(`event ${event} has no id`))
-        return
-      }
-
-      let id = event.id
-      trySend([type, event])
-      pubListeners[id] = { resolve, reject }
-    })
+  public prepareSubscription(filters: Filter[], params: Partial<SubscriptionParams> & { id?: string }): Subscription {
+    this.serial++
+    const id = params.id || 'sub:' + this.serial
+    const subscription = new Subscription(this, id, filters, params)
+    this.openSubs.set(id, subscription)
+    return subscription
   }
 
-  return {
-    url,
-    sub,
-    on: <T extends keyof RelayEvent, U extends RelayEvent[T]>(type: T, cb: U): void => {
-      listeners[type].push(cb)
-      if (type === 'connect' && ws?.readyState === 1) {
-        // i would love to know why we need this
-        ;(cb as () => void)()
-      }
-    },
-    off: <T extends keyof RelayEvent, U extends RelayEvent[T]>(type: T, cb: U): void => {
-      let index = listeners[type].indexOf(cb)
-      if (index !== -1) listeners[type].splice(index, 1)
-    },
-    list: (filters, opts?: SubscriptionOptions) =>
-      new Promise(resolve => {
-        let s = sub(filters, opts)
-        let events: Event<any>[] = []
-        let timeout = setTimeout(() => {
-          s.unsub()
-          resolve(events)
-        }, listTimeout)
-        s.on('eose', () => {
-          s.unsub()
-          clearTimeout(timeout)
-          resolve(events)
-        })
-        s.on('event', event => {
-          events.push(event)
-        })
-      }),
-    get: (filter, opts?: SubscriptionOptions) =>
-      new Promise(resolve => {
-        let s = sub([filter], opts)
-        let timeout = setTimeout(() => {
-          s.unsub()
-          resolve(null)
-        }, getTimeout)
-        s.on('event', event => {
-          s.unsub()
-          clearTimeout(timeout)
-          resolve(event)
-        })
-      }),
-    count: (filters: Filter[]): Promise<CountPayload | null> =>
-      new Promise(resolve => {
-        let s = sub(filters, { ...sub, verb: 'COUNT' })
-        let timeout = setTimeout(() => {
-          s.unsub()
-          resolve(null)
-        }, countTimeout)
-        s.on('count', (event: CountPayload) => {
-          s.unsub()
-          clearTimeout(timeout)
-          resolve(event)
-        })
-      }),
-    async publish(event): Promise<void> {
-      await _publishEvent(event, 'EVENT')
-    },
-    async auth(event): Promise<void> {
-      await _publishEvent(event, 'AUTH')
-    },
-    connect,
-    close(): void {
-      listeners = newListeners()
-      subListeners = {}
-      pubListeners = {}
-      if (ws?.readyState === WebSocket.OPEN) {
-        ws.close()
-      }
-    },
-    get status() {
-      return ws?.readyState ?? 3
-    },
+  public close() {
+    this.closeAllSubscriptions('relay connection closed by us')
+    this._connected = false
+    this.ws?.close()
   }
 }
 
-export async function* eventsGenerator<K extends number>(sub: Sub<K>): AsyncGenerator<Event<K>, void, unknown> {
-  let nextResolve: ((event: Event<K>) => void) | undefined
-  const eventQueue: Event<K>[] = []
+export class Subscription {
+  public readonly relay: Relay
+  public readonly id: string
 
-  const pushToQueue = (event: Event<K>) => {
-    if (nextResolve) {
-      nextResolve(event)
-      nextResolve = undefined
-    } else {
-      eventQueue.push(event)
-    }
+  public closed: boolean = false
+  public eosed: boolean = false
+  public filters: Filter[]
+  public alreadyHaveEvent: ((id: string) => boolean) | undefined
+  public receivedEvent: ((relay: Relay, id: string) => void) | undefined
+
+  public onevent: (evt: Event) => void
+  public oneose: (() => void) | undefined
+  public onclose: ((reason: string) => void) | undefined
+
+  public eoseTimeout: number
+  private eoseTimeoutHandle: ReturnType<typeof setTimeout> | undefined
+
+  constructor(relay: Relay, id: string, filters: Filter[], params: SubscriptionParams) {
+    this.relay = relay
+    this.filters = filters
+    this.id = id
+    this.alreadyHaveEvent = params.alreadyHaveEvent
+    this.receivedEvent = params.receivedEvent
+    this.eoseTimeout = params.eoseTimeout || relay.baseEoseTimeout
+
+    this.oneose = params.oneose
+    this.onclose = params.onclose
+    this.onevent =
+      params.onevent ||
+      (event => {
+        console.warn(
+          `onevent() callback not defined for subscription '${this.id}' in relay ${this.relay.url}. event received:`,
+          event,
+        )
+      })
   }
 
-  sub.on('event', pushToQueue)
+  public fire() {
+    this.relay.send('["REQ","' + this.id + '",' + JSON.stringify(this.filters).substring(1))
 
-  try {
-    while (true) {
-      if (eventQueue.length > 0) {
-        yield eventQueue.shift()!
-      } else {
-        const event = await new Promise<Event<K>>(resolve => {
-          nextResolve = resolve
-        })
-        yield event
-      }
+    // only now we start counting the eoseTimeout
+    this.eoseTimeoutHandle = setTimeout(this.receivedEose.bind(this), this.eoseTimeout)
+  }
+
+  public receivedEose() {
+    if (this.eosed) return
+    clearTimeout(this.eoseTimeoutHandle)
+    this.eosed = true
+    this.oneose?.()
+  }
+
+  public close(reason: string = 'closed by caller') {
+    if (!this.closed) {
+      // if the connection was closed by the user calling .close() we will send a CLOSE message
+      // otherwise this._open will be already set to false so we will skip this
+      this.relay.send('["CLOSE",' + JSON.stringify(this.id) + ']')
+      this.closed = true
     }
-  } finally {
-    sub.off('event', pushToQueue)
+    this.onclose?.(reason)
   }
 }
+
+export type SubscriptionParams = {
+  onevent?: (evt: Event) => void
+  oneose?: () => void
+  onclose?: (reason: string) => void
+  alreadyHaveEvent?: (id: string) => boolean
+  receivedEvent?: (relay: Relay, id: string) => void
+  eoseTimeout?: number
+}
+
+export type CountResolver = {
+  resolve: (count: number) => void
+  reject: (err: Error) => void
+}
+
+export type EventPublishResolver = {
+  resolve: (reason: string) => void
+  reject: (err: Error) => void
+}

test-helpers.ts

@@ -1,12 +1,10 @@
-import type { Event } from './event.ts'
-
-type EventParams<K extends number> = Partial<Event<K>>
+import type { Event } from './pure.ts'
 
 /** Build an event for testing purposes. */
-export function buildEvent<K extends number = 1>(params: EventParams<K>): Event<K> {
+export function buildEvent(params: Partial<Event>): Event {
   return {
     id: '',
-    kind: 1 as K,
+    kind: 1,
     pubkey: '',
     created_at: 0,
     content: '',

tsconfig.json

@@ -12,6 +12,7 @@
     "outDir": "lib/types",
     "resolveJsonModule": true,
     "rootDir": ".",
-    "allowImportingTsExtensions": true
+    "allowImportingTsExtensions": true,
+    "types": ["bun-types"]
   }
 }

utils.test.ts

@@ -1,7 +1,8 @@
+import { describe, test, expect } from 'bun:test'
 import { buildEvent } from './test-helpers.ts'
-import { MessageQueue, insertEventIntoAscendingList, insertEventIntoDescendingList } from './utils.ts'
+import { Queue, insertEventIntoAscendingList, insertEventIntoDescendingList, binarySearch } from './utils.ts'
 
-import type { Event } from './event.ts'
+import type { Event } from './pure.ts'
 
 describe('inserting into a desc sorted list of events', () => {
   test('insert into an empty list', async () => {
@@ -213,29 +214,27 @@ describe('inserting into a asc sorted list of events', () => {
   })
 })
 
-describe('enque a message into MessageQueue', () => {
-  test('enque into an empty queue', () => {
-    const queue = new MessageQueue()
+describe('enqueue a message into MessageQueue', () => {
+  test('enqueue into an empty queue', () => {
+    const queue = new Queue()
     queue.enqueue('node1')
     expect(queue.first!.value).toBe('node1')
   })
-  test('enque into a non-empty queue', () => {
-    const queue = new MessageQueue()
+  test('enqueue into a non-empty queue', () => {
+    const queue = new Queue()
     queue.enqueue('node1')
     queue.enqueue('node3')
     queue.enqueue('node2')
     expect(queue.first!.value).toBe('node1')
     expect(queue.last!.value).toBe('node2')
-    expect(queue.size).toBe(3)
   })
   test('dequeue from an empty queue', () => {
-    const queue = new MessageQueue()
+    const queue = new Queue()
     const item1 = queue.dequeue()
     expect(item1).toBe(null)
-    expect(queue.size).toBe(0)
   })
   test('dequeue from a non-empty queue', () => {
-    const queue = new MessageQueue()
+    const queue = new Queue()
     queue.enqueue('node1')
     queue.enqueue('node3')
     queue.enqueue('node2')
@@ -245,15 +244,22 @@ describe('enque a message into MessageQueue', () => {
     expect(item2).toBe('node3')
   })
   test('dequeue more than in queue', () => {
-    const queue = new MessageQueue()
+    const queue = new Queue()
     queue.enqueue('node1')
     queue.enqueue('node3')
     const item1 = queue.dequeue()
     expect(item1).toBe('node1')
     const item2 = queue.dequeue()
     expect(item2).toBe('node3')
-    expect(queue.size).toBe(0)
     const item3 = queue.dequeue()
     expect(item3).toBe(null)
   })
 })
+
+test('binary search', () => {
+  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('e' < b ? -1 : 'e' === b ? 0 : 1))).toEqual([3, true])
+  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('x' < b ? -1 : 'x' === b ? 0 : 1))).toEqual([4, false])
+  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('c' < b ? -1 : 'c' === b ? 0 : 1))).toEqual([2, false])
+  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('a' < b ? -1 : 'a' === b ? 0 : 1))).toEqual([0, true])
+  expect(binarySearch(['a', 'b', 'd', 'e'], b => ('[' < b ? -1 : '[' === b ? 0 : 1))).toEqual([0, false])
+})

utils.ts

@@ -1,4 +1,4 @@
-import type { Event } from './event.ts'
+import type { Event } from './pure.ts'
 
 export const utf8Decoder = new TextDecoder('utf-8')
 export const utf8Encoder = new TextEncoder()
@@ -13,157 +13,104 @@ export function normalizeURL(url: string): string {
   return p.toString()
 }
 
-//
-// fast insert-into-sorted-array functions adapted from https://github.com/terrymorse58/fast-sorted-array
-//
-export function insertEventIntoDescendingList(sortedArray: Event<number>[], event: Event<number>) {
-  let start = 0
-  let end = sortedArray.length - 1
-  let midPoint
-  let position = start
-
-  if (end < 0) {
-    position = 0
-  } else if (event.created_at < sortedArray[end].created_at) {
-    position = end + 1
-  } else if (event.created_at >= sortedArray[start].created_at) {
-    position = start
-  } else
-    while (true) {
-      if (end <= start + 1) {
-        position = end
-        break
-      }
-      midPoint = Math.floor(start + (end - start) / 2)
-      if (sortedArray[midPoint].created_at > event.created_at) {
-        start = midPoint
-      } else if (sortedArray[midPoint].created_at < event.created_at) {
-        end = midPoint
-      } else {
-        // aMidPoint === num
-        position = midPoint
-        break
-      }
-    }
-
-  // insert when num is NOT already in (no duplicates)
-  if (sortedArray[position]?.id !== event.id) {
-    return [...sortedArray.slice(0, position), event, ...sortedArray.slice(position)]
+export function insertEventIntoDescendingList(sortedArray: Event[], event: Event) {
+  const [idx, found] = binarySearch(sortedArray, b => {
+    if (event.id === b.id) return 0
+    if (event.created_at === b.created_at) return -1
+    return b.created_at - event.created_at
+  })
+  if (!found) {
+    sortedArray.splice(idx, 0, event)
   }
-
   return sortedArray
 }
 
-export function insertEventIntoAscendingList(sortedArray: Event<number>[], event: Event<number>) {
-  let start = 0
-  let end = sortedArray.length - 1
-  let midPoint
-  let position = start
-
-  if (end < 0) {
-    position = 0
-  } else if (event.created_at > sortedArray[end].created_at) {
-    position = end + 1
-  } else if (event.created_at <= sortedArray[start].created_at) {
-    position = start
-  } else
-    while (true) {
-      if (end <= start + 1) {
-        position = end
-        break
-      }
-      midPoint = Math.floor(start + (end - start) / 2)
-      if (sortedArray[midPoint].created_at < event.created_at) {
-        start = midPoint
-      } else if (sortedArray[midPoint].created_at > event.created_at) {
-        end = midPoint
-      } else {
-        // aMidPoint === num
-        position = midPoint
-        break
-      }
-    }
-
-  // insert when num is NOT already in (no duplicates)
-  if (sortedArray[position]?.id !== event.id) {
-    return [...sortedArray.slice(0, position), event, ...sortedArray.slice(position)]
+export function insertEventIntoAscendingList(sortedArray: Event[], event: Event) {
+  const [idx, found] = binarySearch(sortedArray, b => {
+    if (event.id === b.id) return 0
+    if (event.created_at === b.created_at) return -1
+    return event.created_at - b.created_at
+  })
+  if (!found) {
+    sortedArray.splice(idx, 0, event)
   }
-
   return sortedArray
 }
 
-export class MessageNode {
-  private _value: string
-  private _next: MessageNode | null
+export function binarySearch<T>(arr: T[], compare: (b: T) => number): [number, boolean] {
+  let start = 0
+  let end = arr.length - 1
 
-  public get value(): string {
-    return this._value
-  }
-  public set value(message: string) {
-    this._value = message
-  }
-  public get next(): MessageNode | null {
-    return this._next
-  }
-  public set next(node: MessageNode | null) {
-    this._next = node
+  while (start <= end) {
+    const mid = Math.floor((start + end) / 2)
+    const cmp = compare(arr[mid])
+
+    if (cmp === 0) {
+      return [mid, true]
+    }
+
+    if (cmp < 0) {
+      end = mid - 1
+    } else {
+      start = mid + 1
+    }
   }
 
-  constructor(message: string) {
-    this._value = message
-    this._next = null
+  return [start, false]
+}
+
+export class QueueNode<V> {
+  public value: V
+  public next: QueueNode<V> | null = null
+  public prev: QueueNode<V> | null = null
+
+  constructor(message: V) {
+    this.value = message
   }
 }
 
-export class MessageQueue {
-  private _first: MessageNode | null
-  private _last: MessageNode | null
-
-  public get first(): MessageNode | null {
-    return this._first
-  }
-  public set first(messageNode: MessageNode | null) {
-    this._first = messageNode
-  }
-  public get last(): MessageNode | null {
-    return this._last
-  }
-  public set last(messageNode: MessageNode | null) {
-    this._last = messageNode
-  }
-  private _size: number
-  public get size(): number {
-    return this._size
-  }
-  public set size(v: number) {
-    this._size = v
-  }
+export class Queue<V> {
+  public first: QueueNode<V> | null
+  public last: QueueNode<V> | null
 
   constructor() {
-    this._first = null
-    this._last = null
-    this._size = 0
+    this.first = null
+    this.last = null
   }
-  enqueue(message: string): boolean {
-    const newNode = new MessageNode(message)
-    if (this._size === 0 || !this._last) {
-      this._first = newNode
-      this._last = newNode
+
+  enqueue(value: V): boolean {
+    const newNode = new QueueNode(value)
+    if (!this.last) {
+      // list is empty
+      this.first = newNode
+      this.last = newNode
+    } else if (this.last === this.first) {
+      // list has a single element
+      this.last = newNode
+      this.last.prev = this.first
+      this.first.next = newNode
     } else {
-      this._last.next = newNode
-      this._last = newNode
+      // list has elements, add as last
+      newNode.prev = this.last
+      this.last.next = newNode
+      this.last = newNode
     }
-    this._size++
     return true
   }
-  dequeue(): string | null {
-    if (this._size === 0 || !this._first) return null
 
-    let prev = this._first
-    this._first = prev.next
-    prev.next = null
+  dequeue(): V | null {
+    if (!this.first) return null
 
-    this._size--
-    return prev.value
+    if (this.first === this.last) {
+      const target = this.first
+      this.first = null
+      this.last = null
+      return target.value
+    }
+
+    const target = this.first
+    this.first = target.next
+
+    return target.value
   }
 }

wasm.ts

@@ -0,0 +1,38 @@
+import { bytesToHex } from '@noble/hashes/utils'
+import { Nostr as NostrWasm } from 'nostr-wasm'
+import { EventTemplate, Event, Nostr, VerifiedEvent, verifiedSymbol } from './core'
+
+let nw: NostrWasm
+
+export function setNostrWasm(x: NostrWasm) {
+  nw = x
+}
+
+class Wasm implements Nostr {
+  generateSecretKey(): Uint8Array {
+    return nw.generateSecretKey()
+  }
+  getPublicKey(secretKey: Uint8Array): string {
+    return bytesToHex(nw.getPublicKey(secretKey))
+  }
+  finalizeEvent(t: EventTemplate, secretKey: Uint8Array): VerifiedEvent {
+    nw.finalizeEvent(t as any, secretKey)
+    return t as VerifiedEvent
+  }
+  verifyEvent(event: Event): event is VerifiedEvent {
+    try {
+      nw.verifyEvent(event)
+      event[verifiedSymbol] = true
+      return true
+    } catch (err) {
+      return false
+    }
+  }
+}
+
+const i = new Wasm()
+export const generateSecretKey = i.generateSecretKey
+export const getPublicKey = i.getPublicKey
+export const finalizeEvent = i.finalizeEvent
+export const verifyEvent = i.verifyEvent
+export * from './core.ts'