libp2r2p 0.0.1

package/tests/private-message.test.js

@@ -0,0 +1,460 @@
+import { afterEach, test } from 'node:test'
+import assert from 'node:assert/strict'
+import { finalizeEvent, generateSecretKey, getEventHash } from 'nostr-tools'
+import {
+  ASK_KIND,
+  REPLY_KIND,
+  TELL_KIND,
+  broadcastEvent,
+  broadcastNymEvent,
+  broadcastNymRumor,
+  ask,
+  broadcastRumor,
+  parseRumorContent,
+  reply,
+  tell,
+  unwatch,
+  watch,
+  yell
+} from '../private-message/index.js'
+import { keypairFromSeckey } from '../key/index.js'
+
+const data = new Map()
+globalThis.localStorage = {
+  clear: () => data.clear(),
+  getItem: key => data.has(String(key)) ? data.get(String(key)) : null,
+  removeItem: key => { data.delete(String(key)) },
+  setItem: (key, value) => { data.set(String(key), String(value)) }
+}
+
+afterEach(() => {
+  unwatch()
+  globalThis.localStorage.clear()
+})
+
+function signer (pubkey) {
+  return {
+    getPublicKey: () => pubkey,
+    withSharedKey: () => ({})
+  }
+}
+
+function pubkeyFixture (index) {
+  return index.toString(16).padStart(64, '0')
+}
+
+function fakeSubscribeFactory () {
+  const calls = []
+  const closed = []
+  const fakeSubscribe = options => {
+    calls.push(options)
+    return {
+      close: () => closed.push(options)
+    }
+  }
+  return { calls, closed, fakeSubscribe }
+}
+
+test('watch merges overlapping relay subscriptions by channel author', async () => {
+  const { calls, closed, fakeSubscribe } = fakeSubscribeFactory()
+  const channel1 = signer('channel1')
+  const reader1 = signer('reader1')
+  await watch({
+    channels: ['channel1'],
+    relays: ['wss://a.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: channel1,
+    privateChannelReaderSigner: reader1,
+    privateChannelReaderPubkey: 'reader1',
+    _subscribe: fakeSubscribe
+  })
+  await watch({
+    channels: ['channel1'],
+    relays: ['wss://a.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: channel1,
+    privateChannelReaderSigner: reader1,
+    privateChannelReaderPubkey: 'reader1',
+    _subscribe: fakeSubscribe
+  })
+  await watch({
+    channels: ['channel2'],
+    relays: ['wss://a.example', 'wss://b.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: signer('channel2'),
+    privateChannelReaderSigner: signer('reader2'),
+    privateChannelReaderPubkey: 'reader2',
+    mode: 'seeder',
+    _subscribe: fakeSubscribe
+  })
+
+  assert.equal(calls.length, 3)
+  assert.deepEqual(calls[0].privateChannelPubkeys, ['channel1'])
+  assert.deepEqual(calls[0].relays, ['wss://a.example'])
+  assert.equal(calls[0].limit, 0)
+  assert.equal(calls[0].liveOnly, true)
+  assert.deepEqual(calls[1].privateChannelPubkeys.sort(), ['channel1', 'channel2'])
+  assert.deepEqual(calls[1].relays, ['wss://a.example'])
+  assert.deepEqual(calls[1].modeByPubkey, { channel1: 'leecher', channel2: 'seeder' })
+  assert.deepEqual(Object.fromEntries(Object.entries(calls[1].privateChannelReaderSignersByPubkey).map(([channel, nextSigner]) => [channel, nextSigner.getPublicKey()])), {
+    channel1: 'reader1',
+    channel2: 'reader2'
+  })
+  assert.deepEqual(calls[1].privateChannelReaderPubkeysByPubkey, {
+    channel1: 'reader1',
+    channel2: 'reader2'
+  })
+  assert.deepEqual(calls[2].privateChannelPubkeys, ['channel2'])
+  assert.deepEqual(calls[2].relays, ['wss://b.example'])
+
+  await new Promise(resolve => setTimeout(resolve, 550))
+  assert.equal(closed.length, 1)
+  assert.deepEqual(closed[0].privateChannelPubkeys, ['channel1'])
+})
+
+test('watch refresh keeps shared relay subscriptions and gracefully closes removed relays', async () => {
+  const { calls, closed, fakeSubscribe } = fakeSubscribeFactory()
+  await watch({
+    channels: ['channel1'],
+    relays: ['wss://a.example', 'wss://b.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: signer('channel1'),
+    _subscribe: fakeSubscribe
+  })
+  await watch({
+    channels: ['channel1'],
+    relays: ['wss://b.example', 'wss://c.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: signer('channel1'),
+    _subscribe: fakeSubscribe
+  })
+
+  assert.equal(calls.length, 3)
+  assert.deepEqual(calls.map(call => call.relays[0]), ['wss://a.example', 'wss://b.example', 'wss://c.example'])
+  assert.equal(closed.length, 0)
+
+  await new Promise(resolve => setTimeout(resolve, 550))
+  assert.equal(closed.length, 1)
+  assert.deepEqual(closed[0].relays, ['wss://a.example'])
+})
+
+test('ask requires watching the sender private channel first', async () => {
+  await assert.rejects(
+    () => ask({
+      senderSigner: signer('sender'),
+      privateChannelSigner: signer('sender-channel'),
+      receiverPubkey: 'receiver',
+      relays: ['wss://relay.example'],
+      message: { code: 'PING' },
+      _publish: async () => ({ results: [] })
+    }),
+    /PRIVATE_MESSAGE_NOT_WATCHING/
+  )
+})
+
+test('ask from a reader-only channel requires a writer signer', async () => {
+  const { fakeSubscribe } = fakeSubscribeFactory()
+  await watch({
+    channels: ['writer-channel'],
+    relays: ['wss://relay.example'],
+    receiverSigner: signer('sender'),
+    privateChannelSigner: null,
+    privateChannelReaderSigner: signer('reader'),
+    _subscribe: fakeSubscribe
+  })
+
+  await assert.rejects(
+    () => ask({
+      senderSigner: signer('sender'),
+      privateChannelSigner: null,
+      receiverPubkey: 'receiver',
+      relays: ['wss://relay.example'],
+      message: { code: 'PING' },
+      _publish: async () => ({ results: [] })
+    }),
+    /PRIVATE_CHANNEL_WRITER_REQUIRED/
+  )
+})
+
+test('watch dispatches content key usage callbacks', async () => {
+  const { calls, fakeSubscribe } = fakeSubscribeFactory()
+  const usages = []
+  await watch({
+    channels: ['channel1'],
+    relays: ['wss://relay.example'],
+    receiverSigner: signer('receiver'),
+    privateChannelSigner: signer('channel1'),
+    onContentKeyUsage: usage => usages.push(usage),
+    _subscribe: fakeSubscribe
+  })
+
+  calls[0].onContentKeyUsage({
+    channelPubkey: 'channel1',
+    direction: 'sent',
+    contentKeyPubkey: ''
+  })
+
+  assert.deepEqual(usages, [{ channelPubkey: 'channel1', direction: 'sent', contentKeyPubkey: '' }])
+})
+
+test('ask publishes an ask rumor and watch dispatches the reply with its question', async () => {
+  const { calls, fakeSubscribe } = fakeSubscribeFactory()
+  const replies = []
+  let published = null
+  const senderPubkey = pubkeyFixture(1)
+  await watch({
+    channels: ['sender-channel'],
+    relays: ['wss://relay.example'],
+    receiverSigner: signer(senderPubkey),
+    privateChannelSigner: signer('sender-channel'),
+    onReply: event => replies.push(event),
+    _subscribe: fakeSubscribe
+  })
+  const result = await ask({
+    senderSigner: signer(senderPubkey),
+    privateChannelSigner: signer('sender-channel'),
+    privateChannelReaderPubkey: 'reader-channel',
+    receiverPubkey: 'receiver',
+    relays: ['wss://relay.example'],
+    temporaryStorageArea: globalThis.localStorage,
+    message: { code: 'PING', payload: { ok: true } },
+    _publish: async options => {
+      published = options
+      return { results: [{ success: true }] }
+    }
+  })
+
+  assert.equal(published.event.kind, ASK_KIND)
+  assert.equal(published.event.sig, undefined)
+  assert.equal(published.event.id, undefined)
+  assert.equal(published.event.pubkey, undefined)
+  assert.equal(published.receiverTag, 'receiver')
+  assert.deepEqual(published.receivers, ['receiver'])
+  assert.equal(published.privateChannelReaderPubkey, 'reader-channel')
+  assert.equal(published.temporaryStorageArea, globalThis.localStorage)
+  assert.deepEqual(JSON.parse(published.event.content), { ok: true })
+  assert.deepEqual(published.event.tags, [['r', 'receiver'], ['h', 'PING']])
+  assert.equal(result.question.pubkey, senderPubkey)
+  assert.equal(result.question.id, getEventHash({ ...published.event, pubkey: senderPubkey }))
+  assert.throws(() => getEventHash(published.event), /wrong or missing properties/)
+
+  calls[0].onEvent({
+    kind: REPLY_KIND,
+    id: 'reply-id',
+    pubkey: 'receiver',
+    created_at: 1,
+    tags: [['q', result.question.id]],
+    content: 'pong'
+  }, { created_at: 2 }, { channelPubkey: 'sender-channel' })
+
+  assert.equal(replies.length, 1)
+  assert.equal(replies[0].question, undefined)
+  assert.equal(replies[0].questionId, result.question.id)
+  assert.equal(replies[0].reply.pubkey, 'receiver')
+  assert.deepEqual(replies[0].payload, { payload: 'pong' })
+})
+
+test('reply tell and yell publish recognizable private message rumors', async () => {
+  const published = []
+  const bobPubkey = pubkeyFixture(3)
+  const _publish = async options => {
+    published.push(options)
+    return { results: [] }
+  }
+  const question = {
+    id: 'question-id',
+    pubkey: 'alice',
+    kind: ASK_KIND,
+    created_at: 1,
+    tags: [['r', 'bob']],
+    content: '{}'
+  }
+
+  const replyResult = await reply({ senderSigner: signer(bobPubkey), question, relays: ['wss://relay.example'], payload: 'answer', _publish })
+  const tellResult = await tell({ senderSigner: signer(bobPubkey), receiverPubkey: 'alice', relays: ['wss://relay.example'], payload: 'note', _publish })
+  const yellResult = await yell({ senderSigner: signer(bobPubkey), receiverPubkeys: ['alice', 'carol'], relays: ['wss://relay.example'], payload: 'broadcast', _publish })
+  const rawResult = await broadcastRumor({
+    senderSigner: signer(bobPubkey),
+    receiverPubkeys: ['alice', 'carol'],
+    relays: ['wss://relay.example'],
+    rumor: { kind: 9001, created_at: 22, tags: [['x', '1']], content: 'raw' },
+    _publish
+  })
+  const signedEvent = finalizeEvent({ kind: 9002, created_at: 23, tags: [['x', '2']], content: 'signed' }, generateSecretKey())
+  const signedResult = await broadcastEvent({
+    senderSigner: signer(bobPubkey),
+    receiverPubkeys: ['alice', 'carol'],
+    relays: ['wss://relay.example'],
+    event: signedEvent,
+    _publish
+  })
+
+  assert.equal(published[0].event.kind, REPLY_KIND)
+  assert.equal(published[0].event.id, undefined)
+  assert.equal(published[0].event.pubkey, undefined)
+  assert.equal(replyResult.reply.pubkey, bobPubkey)
+  assert.equal(replyResult.reply.id, getEventHash({ ...published[0].event, pubkey: bobPubkey }))
+  assert.deepEqual(published[0].event.tags, [['q', 'question-id'], ['r', 'alice']])
+  assert.equal(published[0].receiverTag, 'alice')
+  assert.equal(published[1].event.kind, TELL_KIND)
+  assert.equal(tellResult.tell.id, getEventHash({ ...published[1].event, pubkey: bobPubkey }))
+  assert.deepEqual(published[1].event.tags, [['r', 'alice']])
+  assert.equal(published[1].receiverTag, 'alice')
+  assert.equal(published[2].event.kind, TELL_KIND)
+  assert.equal(yellResult.yell.id, getEventHash({ ...published[2].event, pubkey: bobPubkey }))
+  assert.deepEqual(published[2].event.tags, [])
+  assert.equal(published[2].receiverTag, '')
+  assert.deepEqual(published[2].receivers, ['alice', 'carol'])
+  assert.equal(published[3].event.kind, 9001)
+  assert.equal(published[3].event.created_at, 22)
+  assert.equal(published[3].event.content, 'raw')
+  assert.equal(published[3].event.id, undefined)
+  assert.equal(published[3].event.pubkey, undefined)
+  assert.equal(published[3].event.sig, undefined)
+  assert.deepEqual(published[3].event.tags, [['x', '1']])
+  assert.equal(published[3].receiverTag, '')
+  assert.deepEqual(published[3].receivers, ['alice', 'carol'])
+  assert.equal(rawResult.rumor.pubkey, bobPubkey)
+  assert.equal(rawResult.rumor.id, getEventHash({ ...published[3].event, pubkey: bobPubkey }))
+  assert.deepEqual(published[4].event, signedEvent)
+  assert.deepEqual(published[4].receivers, ['alice', 'carol'])
+  assert.deepEqual(signedResult.event, signedEvent)
+})
+
+test('private message sends return generated deletion keys and forward supplied pubkeys', async () => {
+  const published = []
+  const _publish = async options => {
+    published.push(options)
+    return { results: [] }
+  }
+  const suppliedPubkey = pubkeyFixture(99).toUpperCase()
+
+  const supplied = await tell({
+    senderSigner: signer(pubkeyFixture(3)),
+    receiverPubkey: 'alice',
+    relays: ['wss://relay.example'],
+    payload: 'supplied',
+    deletionPubkey: suppliedPubkey,
+    _publish
+  })
+  const generated = await broadcastNymRumor({
+    nymSigner: signer(pubkeyFixture(4)),
+    privateChannelSigner: signer(pubkeyFixture(5)),
+    relays: ['wss://relay.example'],
+    rumor: { kind: 9001, created_at: 1, tags: [], content: 'generated' },
+    _publish
+  })
+
+  assert.equal(supplied.deletionPubkey, suppliedPubkey.toLowerCase())
+  assert.equal('deletionSeckey' in supplied, false)
+  assert.equal(published[0].deletionPubkey, suppliedPubkey.toLowerCase())
+  assert.match(generated.deletionPubkey, /^[0-9a-f]{64}$/)
+  assert.match(generated.deletionSeckey, /^[0-9a-f]{64}$/)
+  assert.equal(keypairFromSeckey(generated.deletionSeckey).pubkey, generated.deletionPubkey)
+  assert.equal(published[1].deletionPubkey, generated.deletionPubkey)
+
+  await assert.rejects(
+    () => tell({
+      senderSigner: signer(pubkeyFixture(3)),
+      receiverPubkey: 'alice',
+      relays: ['wss://relay.example'],
+      payload: 'bad key',
+      deletionPubkey: 'not-a-pubkey',
+      _publish
+    }),
+    /INVALID_DELETION_PUBKEY/
+  )
+})
+
+test('broadcastRumor validates normalized unsigned rumors before publishing', async () => {
+  let published = false
+
+  await assert.rejects(
+    () => broadcastRumor({
+      senderSigner: signer(pubkeyFixture(4)),
+      receiverPubkeys: ['alice'],
+      relays: ['wss://relay.example'],
+      rumor: { kind: 9001, created_at: 22, tags: ['not-a-tag'], content: 'raw' },
+      _publish: async () => { published = true }
+    }),
+    /INVALID_RUMOR/
+  )
+
+  assert.equal(published, false)
+})
+
+test('broadcastEvent refuses unsigned or invalid signed events', async () => {
+  const valid = finalizeEvent({ kind: 9002, created_at: 23, tags: [], content: 'signed' }, generateSecretKey())
+  let published = false
+
+  await assert.rejects(
+    () => broadcastEvent({
+      senderSigner: signer(pubkeyFixture(5)),
+      receiverPubkeys: ['alice'],
+      relays: ['wss://relay.example'],
+      event: { ...valid, content: 'tampered' },
+      _publish: async () => { published = true }
+    }),
+    /INVALID_SIGNED_EVENT/
+  )
+  await assert.rejects(
+    () => broadcastEvent({
+      senderSigner: signer(pubkeyFixture(5)),
+      receiverPubkeys: ['alice'],
+      relays: ['wss://relay.example'],
+      event: { kind: 9002, created_at: 23, tags: [], content: 'unsigned' },
+      _publish: async () => { published = true }
+    }),
+    /INVALID_SIGNED_EVENT/
+  )
+
+  assert.equal(published, false)
+})
+
+test('nym broadcasts publish through the nym channel path without receivers', async () => {
+  const published = []
+  const nymPubkey = pubkeyFixture(6)
+  const channelPubkey = pubkeyFixture(7)
+  const authorEvent = finalizeEvent({ kind: 9002, created_at: 30, tags: [], content: 'signed by another key' }, generateSecretKey())
+  const _publish = async options => {
+    published.push(options)
+    return { results: [] }
+  }
+
+  const rumorResult = await broadcastNymRumor({
+    nymSigner: signer(nymPubkey),
+    privateChannelSigner: signer(channelPubkey),
+    relays: ['wss://relay.example'],
+    rumor: { kind: 9001, created_at: 29, tags: [['x', 'nym']], content: 'rumor' },
+    _publish
+  })
+  const eventResult = await broadcastNymEvent({
+    nymSigner: signer(nymPubkey),
+    privateChannelSigner: signer(channelPubkey),
+    relays: ['wss://relay.example'],
+    event: authorEvent,
+    _publish
+  })
+
+  assert.equal(published.length, 2)
+  assert.equal(published[0].nymSigner.getPublicKey(), nymPubkey)
+  assert.equal(published[0].privateChannelSigner.getPublicKey(), channelPubkey)
+  assert.equal(published[0].event.pubkey, undefined)
+  assert.equal(published[0].event.id, undefined)
+  assert.equal(rumorResult.rumor.pubkey, nymPubkey)
+  assert.equal(rumorResult.rumor.id, getEventHash({ ...published[0].event, pubkey: nymPubkey }))
+  assert.deepEqual(published[1].event, authorEvent)
+  assert.notEqual(published[1].event.pubkey, nymPubkey)
+  assert.deepEqual(eventResult.event, authorEvent)
+})
+
+test('parseRumorContent only reads h tags for private message kinds', () => {
+  assert.deepEqual(
+    parseRumorContent({ kind: TELL_KIND, tags: [['h', 'NOTE']], content: 'hello' }),
+    { payload: 'hello', code: 'NOTE' }
+  )
+  assert.deepEqual(
+    parseRumorContent({ kind: 9001, content: JSON.stringify(['hello', 'NOTE']) }),
+    ['hello', 'NOTE']
+  )
+})