utils: merging two (reverse) sorted lists of events.

this was so obvious.

README.md

@@ -1,4 +1,4 @@
-# ![](https://img.shields.io/github/actions/workflow/status/nbd-wtf/nostr-tools/test.yml) [![JSR](https://jsr.io/badges/@nostr/tools)](https://jsr.io/@nostr/tools) nostr-tools
+# [![JSR](https://jsr.io/badges/@nostr/tools)](https://jsr.io/@nostr/tools) @nostr/tools
 
 Tools for developing [Nostr](https://github.com/fiatjaf/nostr) clients.
 
@@ -9,9 +9,6 @@ This package is only providing lower-level functionality. If you want higher-lev
 ## Installation
 
 ```bash
-# npm
-npm install --save nostr-tools
-
 # jsr
 npx jsr add @nostr/tools
 ```
@@ -27,7 +24,7 @@ https://jsr.io/@nostr/tools/doc
 ### Generating a private key and a public key
 
 ```js
-import { generateSecretKey, getPublicKey } from 'nostr-tools/pure'
+import { generateSecretKey, getPublicKey } from '@nostr/tools/pure'
 
 let sk = generateSecretKey() // `sk` is a Uint8Array
 let pk = getPublicKey(sk) // `pk` is a hex string
@@ -36,7 +33,7 @@ let pk = getPublicKey(sk) // `pk` is a hex string
 To get the secret key in hex format, use
 
 ```js
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils' // already an installed dependency
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js' // already an installed dependency
 
 let skHex = bytesToHex(sk)
 let backToBytes = hexToBytes(skHex)
@@ -45,7 +42,7 @@ let backToBytes = hexToBytes(skHex)
 ### Creating, signing and verifying events
 
 ```js
-import { finalizeEvent, verifyEvent } from 'nostr-tools/pure'
+import { finalizeEvent, verifyEvent } from '@nostr/tools/pure'
 
 let event = finalizeEvent({
   kind: 1,
@@ -62,8 +59,8 @@ let isGood = verifyEvent(event)
 Doesn't matter what you do, you always should be using a `SimplePool`:
 
 ```js
-import { finalizeEvent, generateSecretKey, getPublicKey } from 'nostr-tools/pure'
+import { finalizeEvent, generateSecretKey, getPublicKey } from '@nostr/tools/pure'
-import { SimplePool } from 'nostr-tools/pool'
+import { SimplePool } from '@nostr/tools/pool'
 
 const pool = new SimplePool()
 
@@ -126,8 +123,8 @@ relay.close()
 To use this on Node.js you first must install `ws` and call something like this:
 
 ```js
-import { useWebSocketImplementation } from 'nostr-tools/pool'
+import { useWebSocketImplementation } from '@nostr/tools/pool'
-// or import { useWebSocketImplementation } from 'nostr-tools/relay' if you're using the Relay directly
+// or import { useWebSocketImplementation } from '@nostr/tools/relay' if you're using the Relay directly
 
 import WebSocket from 'ws'
 useWebSocketImplementation(WebSocket)
@@ -138,7 +135,7 @@ useWebSocketImplementation(WebSocket)
 You can enable regular pings of connected relays with the `enablePing` option. This will set up a heartbeat that closes the websocket if it doesn't receive a response in time. Some platforms, like Node.js, don't report websocket disconnections due to network issues, and enabling this can increase the reliability of the `onclose` event.
 
 ```js
-import { SimplePool } from 'nostr-tools/pool'
+import { SimplePool } from '@nostr/tools/pool'
 
 const pool = new SimplePool({ enablePing: true })
 ```
@@ -148,7 +145,7 @@ const pool = new SimplePool({ enablePing: true })
 You can also enable automatic reconnection with the `enableReconnect` option. This will make the pool try to reconnect to relays with an exponential backoff delay if the connection is lost unexpectedly.
 
 ```js
-import { SimplePool } from 'nostr-tools/pool'
+import { SimplePool } from '@nostr/tools/pool'
 
 const pool = new SimplePool({ enableReconnect: true })
 ```
@@ -331,7 +328,7 @@ for (let profile of refs.profiles) {
 ### Querying profile data from a NIP-05 address
 
 ```js
-import { queryProfile } from 'nostr-tools/nip05'
+import { queryProfile } from '@nostr/tools/nip05'
 
 let profile = await queryProfile('jb55.com')
 console.log(profile.pubkey)
@@ -343,13 +340,13 @@ console.log(profile.relays)
 To use this on Node.js < v18, you first must install `node-fetch@2` and call something like this:
 
 ```js
-import { useFetchImplementation } from 'nostr-tools/nip05'
+import { useFetchImplementation } from '@nostr/tools/nip05'
 useFetchImplementation(require('node-fetch'))
 ```
 
 ### Including NIP-07 types
 ```js
-import type { WindowNostr } from 'nostr-tools/nip07'
+import type { WindowNostr } from '@nostr/tools/nip07'
 
 declare global {
   interface Window {
@@ -361,8 +358,8 @@ declare global {
 ### Encoding and decoding NIP-19 codes
 
 ```js
-import { generateSecretKey, getPublicKey } from 'nostr-tools/pure'
+import { generateSecretKey, getPublicKey } from '@nostr/tools/pure'
-import * as nip19 from 'nostr-tools/nip19'
+import * as nip19 from '@nostr/tools/nip19'
 
 let sk = generateSecretKey()
 let nsec = nip19.nsecEncode(sk)
@@ -390,7 +387,7 @@ assert(data.relays.length === 2)
 [`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 { setNostrWasm, generateSecretKey, finalizeEvent, verifyEvent } from 'nostr-tools/wasm'
+import { setNostrWasm, generateSecretKey, finalizeEvent, verifyEvent } from '@nostr/tools/wasm'
 import { initNostrWasm } from 'nostr-wasm'
 
 // make sure this promise resolves before your app starts calling finalizeEvent or verifyEvent
@@ -403,9 +400,9 @@ initNostrWasm().then(setNostrWasm)
 If you're going to use `Relay` and `SimplePool` you must also import `nostr-tools/abstract-relay` and/or `nostr-tools/abstract-pool` instead of the defaults and then instantiate them by passing the `verifyEvent`:
 
 ```js
-import { setNostrWasm, verifyEvent } from 'nostr-tools/wasm'
+import { setNostrWasm, verifyEvent } from '@nostr/tools/wasm'
-import { AbstractRelay } from 'nostr-tools/abstract-relay'
+import { AbstractRelay } from '@nostr/tools/abstract-relay'
-import { AbstractSimplePool } from 'nostr-tools/abstract-pool'
+import { AbstractSimplePool } from '@nostr/tools/abstract-pool'
 import { initNostrWasm } from 'nostr-wasm'
 
 initNostrWasm().then(setNostrWasm)
@@ -442,7 +439,7 @@ summary for relay read message and verify event
 
 ## Plumbing
 
-To develop `nostr-tools`, install [`just`](https://just.systems/) and run `just -l` to see commands available.
+To develop `@nostr/tools`, install [`just`](https://just.systems/) and run `just -l` to see commands available.
 
 ## License
 

abstract-pool.ts

@@ -11,6 +11,7 @@ import { normalizeURL } from './utils.ts'
 import type { Event, EventTemplate, Nostr, VerifiedEvent } from './core.ts'
 import { type Filter } from './filter.ts'
 import { alwaysTrue } from './helpers.ts'
+import { Relay } from './relay.ts'
 
 export type SubCloser = { close: (reason?: string) => void }
 
@@ -19,6 +20,16 @@ export type AbstractPoolConstructorOptions = AbstractRelayConstructorOptions & {
   // in case that relay shouldn't be authenticated against
   // or a function to sign the AUTH event template otherwise (that function may still throw in case of failure)
   automaticallyAuth?: (relayURL: string) => null | ((event: EventTemplate) => Promise<VerifiedEvent>)
+  // onRelayConnectionFailure is called with the URL of a relay that failed the initial connection
+  onRelayConnectionFailure?: (url: string) => void
+  // onRelayConnectionSuccess is called with the URL of a relay that succeeds the initial connection
+  onRelayConnectionSuccess?: (url: string) => void
+  // allowConnectingToRelay takes a relay URL and the operation being performed
+  // return false to skip connecting to that relay
+  allowConnectingToRelay?: (url: string, operation: ['read', Filter[]] | ['write', Event]) => boolean
+  // maxWaitForConnection takes a number in milliseconds that will be given to ensureRelay such that we
+  // don't get stuck forever when attempting to connect to a relay, it is 3000 (3 seconds) by default
+  maxWaitForConnection: number
 }
 
 export type SubscribeManyParams = Omit<SubscriptionParams, 'onclose'> & {
@@ -40,6 +51,10 @@ export class AbstractSimplePool {
   public enableReconnect: boolean
   public automaticallyAuth?: (relayURL: string) => null | ((event: EventTemplate) => Promise<VerifiedEvent>)
   public trustedRelayURLs: Set<string> = new Set()
+  public onRelayConnectionFailure?: (url: string) => void
+  public onRelayConnectionSuccess?: (url: string) => void
+  public allowConnectingToRelay?: (url: string, operation: ['read', Filter[]] | ['write', Event]) => boolean
+  public maxWaitForConnection: number
 
   private _WebSocket?: typeof WebSocket
 
@@ -49,6 +64,10 @@ export class AbstractSimplePool {
     this.enablePing = opts.enablePing
     this.enableReconnect = opts.enableReconnect || false
     this.automaticallyAuth = opts.automaticallyAuth
+    this.onRelayConnectionFailure = opts.onRelayConnectionFailure
+    this.onRelayConnectionSuccess = opts.onRelayConnectionSuccess
+    this.allowConnectingToRelay = opts.allowConnectingToRelay
+    this.maxWaitForConnection = opts.maxWaitForConnection || 3000
   }
 
   async ensureRelay(
@@ -181,17 +200,28 @@ export class AbstractSimplePool {
     // open a subscription in all given relays
     const allOpened = Promise.all(
       groupedRequests.map(async ({ url, filters }, i) => {
+        if (this.allowConnectingToRelay?.(url, ['read', filters]) === false) {
+          handleClose(i, 'connection skipped by allowConnectingToRelay')
+          return
+        }
+
         let relay: AbstractRelay
         try {
           relay = await this.ensureRelay(url, {
-            connectionTimeout: params.maxWait ? Math.max(params.maxWait * 0.8, params.maxWait - 1000) : undefined,
+            connectionTimeout:
+              this.maxWaitForConnection < (params.maxWait || 0)
+                ? Math.max(params.maxWait! * 0.8, params.maxWait! - 1000)
+                : this.maxWaitForConnection,
             abort: params.abort,
           })
         } catch (err) {
+          this.onRelayConnectionFailure?.(url)
           handleClose(i, (err as any)?.message || String(err))
           return
         }
 
+        this.onRelayConnectionSuccess?.(url)
+
         let subscription = relay.subscribe(filters, {
           ...params,
           oneose: () => handleEose(i),
@@ -298,7 +328,11 @@ export class AbstractSimplePool {
   publish(
     relays: string[],
     event: Event,
-    options?: { onauth?: (evt: EventTemplate) => Promise<VerifiedEvent> },
+    params?: {
+      onauth?: (evt: EventTemplate) => Promise<VerifiedEvent>
+      maxWait?: number
+      abort?: AbortSignal
+    },
   ): Promise<string>[] {
     return relays.map(normalizeURL).map(async (url, i, arr) => {
       if (arr.indexOf(url) !== i) {
@@ -306,12 +340,29 @@ export class AbstractSimplePool {
         return Promise.reject('duplicate url')
       }
 
-      let r = await this.ensureRelay(url)
+      if (this.allowConnectingToRelay?.(url, ['write', event]) === false) {
+        return Promise.reject('connection skipped by allowConnectingToRelay')
+      }
+
+      let r: Relay
+      try {
+        r = await this.ensureRelay(url, {
+          connectionTimeout:
+            this.maxWaitForConnection < (params?.maxWait || 0)
+              ? Math.max(params!.maxWait! * 0.8, params!.maxWait! - 1000)
+              : this.maxWaitForConnection,
+          abort: params?.abort,
+        })
+      } catch (err) {
+        this.onRelayConnectionFailure?.(url)
+        return String('connection failure: ' + String(err))
+      }
+
       return r
         .publish(event)
         .catch(async err => {
-          if (err instanceof Error && err.message.startsWith('auth-required: ') && options?.onauth) {
+          if (err instanceof Error && err.message.startsWith('auth-required: ') && params?.onauth) {
-            await r.auth(options.onauth)
+            await r.auth(params.onauth)
             return r.publish(event) // retry
           }
           throw err

abstract-relay.ts

@@ -45,7 +45,7 @@ export class AbstractRelay {
   private reconnectTimeoutHandle: ReturnType<typeof setTimeout> | undefined
   private pingIntervalHandle: ReturnType<typeof setInterval> | undefined
   private reconnectAttempts: number = 0
-  private closedIntentionally: boolean = false
+  private skipReconnection: boolean = false
 
   private connectionPromise: Promise<void> | undefined
   private openCountRequests = new Map<string, CountResolver>()
@@ -120,12 +120,9 @@ export class AbstractRelay {
     this._connected = false
     this.connectionPromise = undefined
 
-    const wasIntentional = this.closedIntentionally
-    this.closedIntentionally = false // reset for next time
-
     this.onclose?.()
 
-    if (this.enableReconnect && !wasIntentional) {
+    if (this.enableReconnect && !this.skipReconnection) {
       this.reconnect()
     } else {
       this.closeAllSubscriptions(reason)
@@ -139,13 +136,15 @@ export class AbstractRelay {
 
     this.challenge = undefined
     this.authPromise = undefined
+    this.skipReconnection = false
     this.connectionPromise = new Promise((resolve, reject) => {
       if (opts?.timeout) {
         connectionTimeoutHandle = setTimeout(() => {
           reject('connection timed out')
           this.connectionPromise = undefined
+          this.skipReconnection = true
           this.onclose?.()
-          this.closeAllSubscriptions('relay connection timed out')
+          this.handleHardClose('relay connection timed out')
         }, opts.timeout)
       }
 
@@ -191,10 +190,13 @@ export class AbstractRelay {
         resolve()
       }
 
-      this.ws.onerror = ev => {
+      this.ws.onerror = () => {
         clearTimeout(connectionTimeoutHandle)
-        reject((ev as any).message || 'websocket error')
+        reject('connection failed')
-        this.handleHardClose('relay connection errored')
+        this.connectionPromise = undefined
+        this.skipReconnection = true
+        this.onclose?.()
+        this.handleHardClose('relay connection failed')
       }
 
       this.ws.onclose = ev => {
@@ -466,7 +468,7 @@ export class AbstractRelay {
   }
 
   public close() {
-    this.closedIntentionally = true
+    this.skipReconnection = true
     if (this.reconnectTimeoutHandle) {
       clearTimeout(this.reconnectTimeoutHandle)
       this.reconnectTimeoutHandle = undefined

jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@nostr/tools",
-  "version": "2.20.0",
+  "version": "2.22.2",
   "exports": {
     ".": "./index.ts",
     "./core": "./core.ts",

nip04.ts

@@ -1,6 +1,6 @@
-import { bytesToHex, hexToBytes, randomBytes } from '@noble/hashes/utils.js'
+import { hexToBytes, randomBytes } from '@noble/hashes/utils.js'
 import { secp256k1 } from '@noble/curves/secp256k1.js'
-import { cbc } from '@noble/ciphers/aes'
+import { cbc } from '@noble/ciphers/aes.js'
 import { base64 } from '@scure/base'
 
 import { utf8Decoder, utf8Encoder } from './utils.ts'

nip06.ts

@@ -1,5 +1,5 @@
 import { bytesToHex } from '@noble/hashes/utils.js'
-import { wordlist } from '@scure/bip39/wordlists/english'
+import { wordlist } from '@scure/bip39/wordlists/english.js'
 import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'
 import { HDKey } from '@scure/bip32'
 

nip19.ts

@@ -110,7 +110,7 @@ export function decode(nip19: NPub): DecodedNpub
 export function decode(nip19: Note): DecodedNote
 export function decode(code: string): DecodedResult
 export function decode(code: string): DecodedResult {
-  let { prefix, words } = bech32.decode(code, Bech32MaxSize)
+  let { prefix, words } = bech32.decode(code as `${string}1${string}`, Bech32MaxSize)
   let data = new Uint8Array(bech32.fromWords(words))
 
   switch (prefix) {

nip44.ts

@@ -1,5 +1,5 @@
-import { chacha20 } from '@noble/ciphers/chacha'
+import { chacha20 } from '@noble/ciphers/chacha.js'
-import { equalBytes } from '@noble/ciphers/utils'
+import { equalBytes } from '@noble/ciphers/utils.js'
 import { secp256k1 } from '@noble/curves/secp256k1.js'
 import { extract as hkdf_extract, expand as hkdf_expand } from '@noble/hashes/hkdf.js'
 import { hmac } from '@noble/hashes/hmac.js'

nip49.ts

@@ -1,8 +1,8 @@
+import { bech32 } from '@scure/base'
 import { scrypt } from '@noble/hashes/scrypt.js'
-import { xchacha20poly1305 } from '@noble/ciphers/chacha'
+import { xchacha20poly1305 } from '@noble/ciphers/chacha.js'
 import { concatBytes, randomBytes } from '@noble/hashes/utils.js'
 import { Bech32MaxSize, Ncryptsec, encodeBytes } from './nip19.ts'
-import { bech32 } from '@scure/base'
 
 export function encrypt(
   sec: Uint8Array,
@@ -22,7 +22,7 @@ export function encrypt(
 }
 
 export function decrypt(ncryptsec: string, password: string): Uint8Array {
-  let { prefix, words } = bech32.decode(ncryptsec, Bech32MaxSize)
+  let { prefix, words } = bech32.decode(ncryptsec as `${string}1${string}`, Bech32MaxSize)
   if (prefix !== 'ncryptsec') {
     throw new Error(`invalid prefix ${prefix}, expected 'ncryptsec'`)
   }

nip77.ts

@@ -1,4 +1,4 @@
-import { bytesToHex, hexToBytes } from '@noble/ciphers/utils'
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js'
 import { Filter } from './filter.ts'
 import { AbstractRelay, Subscription } from './relay.ts'
 import { sha256 } from '@noble/hashes/sha2.js'

package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "nostr-tools",
-  "version": "2.20.0",
+  "version": "2.22.2",
   "description": "Tools for making a Nostr client.",
   "repository": {
     "type": "git",
@@ -236,12 +236,12 @@
   },
   "license": "Unlicense",
   "dependencies": {
-    "@noble/ciphers": "^0.5.1",
+    "@noble/ciphers": "2.1.1",
-    "@noble/curves": "^2.0.1",
+    "@noble/curves": "2.0.1",
-    "@noble/hashes": "^2.0.1",
+    "@noble/hashes": "2.0.1",
-    "@scure/base": "1.1.1",
+    "@scure/base": "2.0.0",
-    "@scure/bip32": "1.3.1",
+    "@scure/bip32": "2.0.1",
-    "@scure/bip39": "1.2.1",
+    "@scure/bip39": "2.0.1",
     "nostr-wasm": "0.1.0"
   },
   "peerDependencies": {

pool.ts

@@ -15,7 +15,7 @@ export function useWebSocketImplementation(websocketImplementation: any) {
 
 export class SimplePool extends AbstractSimplePool {
   constructor(options?: Pick<AbstractPoolConstructorOptions, 'enablePing' | 'enableReconnect'>) {
-    super({ verifyEvent, websocketImplementation: _WebSocket, ...options })
+    super({ verifyEvent, websocketImplementation: _WebSocket, maxWaitForConnection: 3000, ...options })
   }
 }
 

utils.test.ts

@@ -6,6 +6,7 @@ import {
   insertEventIntoDescendingList,
   binarySearch,
   normalizeURL,
+  mergeReverseSortedLists,
 } from './utils.ts'
 
 import type { Event } from './core.ts'
@@ -270,6 +271,94 @@ test('binary search', () => {
   expect(binarySearch(['a', 'b', 'd', 'e'], b => ('[' < b ? -1 : '[' === b ? 0 : 1))).toEqual([0, false])
 })
 
+describe('mergeReverseSortedLists', () => {
+  test('merge empty lists', () => {
+    const list1: Event[] = []
+    const list2: Event[] = []
+    expect(mergeReverseSortedLists(list1, list2)).toHaveLength(0)
+  })
+
+  test('merge list with empty list', () => {
+    const list1 = [buildEvent({ id: 'a', created_at: 30 }), buildEvent({ id: 'b', created_at: 20 })]
+    const list2: Event[] = []
+    const result = mergeReverseSortedLists(list1, list2)
+    expect(result).toHaveLength(2)
+    expect(result.map(e => e.id)).toEqual(['a', 'b'])
+  })
+
+  test('merge two simple lists', () => {
+    const list1 = [
+      buildEvent({ id: 'a', created_at: 30 }),
+      buildEvent({ id: 'b', created_at: 10 }),
+      buildEvent({ id: 'f', created_at: 3 }),
+      buildEvent({ id: 'g', created_at: 2 }),
+    ]
+    const list2 = [
+      buildEvent({ id: 'c', created_at: 25 }),
+      buildEvent({ id: 'd', created_at: 5 }),
+      buildEvent({ id: 'e', created_at: 1 }),
+    ]
+    const result = mergeReverseSortedLists(list1, list2)
+    expect(result.map(e => e.id)).toEqual(['a', 'c', 'b', 'd', 'f', 'g', 'e'])
+  })
+
+  test('merge lists with same timestamps', () => {
+    const list1 = [
+      buildEvent({ id: 'a', created_at: 30 }),
+      buildEvent({ id: 'b', created_at: 20 }),
+      buildEvent({ id: 'f', created_at: 10 }),
+    ]
+    const list2 = [
+      buildEvent({ id: 'c', created_at: 30 }),
+      buildEvent({ id: 'd', created_at: 20 }),
+      buildEvent({ id: 'e', created_at: 20 }),
+    ]
+    const result = mergeReverseSortedLists(list1, list2)
+    expect(result.map(e => e.id)).toEqual(['c', 'a', 'd', 'e', 'b', 'f'])
+  })
+
+  test('deduplicate events with same timestamp and id', () => {
+    const list1 = [
+      buildEvent({ id: 'a', created_at: 30 }),
+      buildEvent({ id: 'b', created_at: 20 }),
+      buildEvent({ id: 'b', created_at: 20 }),
+      buildEvent({ id: 'c', created_at: 20 }),
+      buildEvent({ id: 'd', created_at: 10 }),
+    ]
+    const list2 = [
+      buildEvent({ id: 'a', created_at: 30 }),
+      buildEvent({ id: 'c', created_at: 20 }),
+      buildEvent({ id: 'b', created_at: 20 }),
+      buildEvent({ id: 'd', created_at: 10 }),
+      buildEvent({ id: 'e', created_at: 10 }),
+      buildEvent({ id: 'd', created_at: 10 }),
+    ]
+    console.log('==================')
+    const result = mergeReverseSortedLists(list1, list2)
+    console.log(
+      'result:',
+      result.map(e => e.id),
+    )
+    expect(result.map(e => e.id)).toEqual(['a', 'c', 'b', 'd', 'e'])
+  })
+
+  test('merge when one list is completely before the other', () => {
+    const list1 = [buildEvent({ id: 'a', created_at: 50 }), buildEvent({ id: 'b', created_at: 40 })]
+    const list2 = [buildEvent({ id: 'c', created_at: 30 }), buildEvent({ id: 'd', created_at: 20 })]
+    const result = mergeReverseSortedLists(list1, list2)
+    expect(result).toHaveLength(4)
+    expect(result.map(e => e.id)).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  test('merge when one list is completely after the other', () => {
+    const list1 = [buildEvent({ id: 'a', created_at: 10 }), buildEvent({ id: 'b', created_at: 5 })]
+    const list2 = [buildEvent({ id: 'c', created_at: 30 }), buildEvent({ id: 'd', created_at: 20 })]
+    const result = mergeReverseSortedLists(list1, list2)
+    expect(result).toHaveLength(4)
+    expect(result.map(e => e.id)).toEqual(['c', 'd', 'a', 'b'])
+  })
+})
+
 describe('normalizeURL', () => {
   test('normalizes wss:// URLs', () => {
     expect(normalizeURL('wss://example.com')).toBe('wss://example.com/')

utils.ts

@@ -1,4 +1,4 @@
-import type { Event } from './core.ts'
+import type { NostrEvent } from './core.ts'
 
 export const utf8Decoder: TextDecoder = new TextDecoder('utf-8')
 export const utf8Encoder: TextEncoder = new TextEncoder()
@@ -22,7 +22,7 @@ export function normalizeURL(url: string): string {
   }
 }
 
-export function insertEventIntoDescendingList(sortedArray: Event[], event: Event): Event[] {
+export function insertEventIntoDescendingList(sortedArray: NostrEvent[], event: NostrEvent): NostrEvent[] {
   const [idx, found] = binarySearch(sortedArray, b => {
     if (event.id === b.id) return 0
     if (event.created_at === b.created_at) return -1
@@ -34,7 +34,7 @@ export function insertEventIntoDescendingList(sortedArray: Event[], event: Event
   return sortedArray
 }
 
-export function insertEventIntoAscendingList(sortedArray: Event[], event: Event): Event[] {
+export function insertEventIntoAscendingList(sortedArray: NostrEvent[], event: NostrEvent): NostrEvent[] {
   const [idx, found] = binarySearch(sortedArray, b => {
     if (event.id === b.id) return 0
     if (event.created_at === b.created_at) return -1
@@ -68,6 +68,62 @@ export function binarySearch<T>(arr: T[], compare: (b: T) => number): [number, b
   return [start, false]
 }
 
+export function mergeReverseSortedLists(list1: NostrEvent[], list2: NostrEvent[]): NostrEvent[] {
+  const result: NostrEvent[] = new Array(list1.length + list2.length)
+  result.length = 0
+  let i1 = 0
+  let i2 = 0
+  let sameTimestampIds: string[] = []
+
+  while (i1 < list1.length && i2 < list2.length) {
+    let next: NostrEvent
+    if (list1[i1]?.created_at > list2[i2]?.created_at) {
+      next = list1[i1]
+      i1++
+    } else {
+      next = list2[i2]
+      i2++
+    }
+
+    if (result.length > 0 && result[result.length - 1].created_at === next.created_at) {
+      if (sameTimestampIds.includes(next.id)) continue
+    } else {
+      sameTimestampIds.length = 0
+    }
+
+    result.push(next)
+    sameTimestampIds.push(next.id)
+  }
+
+  while (i1 < list1.length) {
+    const next = list1[i1]
+    i1++
+
+    if (result.length > 0 && result[result.length - 1].created_at === next.created_at) {
+      if (sameTimestampIds.includes(next.id)) continue
+    } else {
+      sameTimestampIds.length = 0
+    }
+    result.push(next)
+    sameTimestampIds.push(next.id)
+  }
+
+  while (i2 < list2.length) {
+    const next = list2[i2]
+    i2++
+
+    if (result.length > 0 && result[result.length - 1].created_at === next.created_at) {
+      if (sameTimestampIds.includes(next.id)) continue
+    } else {
+      sameTimestampIds.length = 0
+    }
+    result.push(next)
+    sameTimestampIds.push(next.id)
+  }
+
+  return result
+}
+
 export class QueueNode<V> {
   public value: V
   public next: QueueNode<V> | null = null