@nostrwatch/route66 0.0.1

package/src/core/WebsocketAdapter.ts

@@ -0,0 +1,438 @@
+import type { Filter } from 'nostr-tools';
+
+import { Adapter, AdapterMessage, type IAdapter } from './Adapter'
+import type { IEvent } from '@models/Event';
+import { deterministicHash } from '@base/utils/hash';
+import { WebsocketResponseBody } from './AdapterWebsocketWorker';
+import { StateManager } from '@base/managers/StateManager';
+import { delay } from '@nostrwatch/utils';
+
+export interface SubscribeHandlers {
+  onevent?: (event: any) => void
+  onevents?: (events: any[]) => void
+  oneose?: () => void
+  onclose?: (subId: string) => void
+}
+export interface IWebsocketAdapterCallbacks {
+  onNotice?: (notice: any) => void
+  onOk?: (status: any) => void
+  onEvent?: (event: IEvent) => void
+  onLimits?: (limits: Record<string, any>) => void
+  onEose?: () => void
+  onClose?: () => void
+}
+
+export interface WebsocketAdapterOptions {
+ keepAlive: boolean,
+ returnResults: boolean,
+ cache: boolean,
+ stream: boolean,
+ batch?: number
+}
+
+export const defaultWebsocketAdapterOptions: WebsocketAdapterOptions = {
+  keepAlive: false,
+  returnResults: false,
+  cache: true,
+  stream: true
+}
+
+export interface WebsocketRequest extends WebsocketRequestHeader {
+  args: WebsocketRequestBody
+}
+
+export interface WebsocketRequestHeader {
+  adapter: string,
+  from: string,
+  action: string,
+}
+
+export type WebsocketRequestBody = {
+  options: WebsocketAdapterOptions,
+  filters?: Filter[],
+  note?: IEvent,
+  hash?: string,
+  relays?: string[],
+  priority?: number
+}
+
+export const defaultWebsocketRequestHeader: WebsocketRequestHeader = {
+  adapter: 'websocket',
+  from: 'worker',
+  action: 'fetch',
+}
+
+export const defaultWebsocketRequestBody: WebsocketRequestBody = {
+  filters: [],
+  options: defaultWebsocketAdapterOptions,
+  hash: '',
+  relays: []
+}
+
+export const defaultWebsocketRequest: WebsocketRequest = {
+  ...defaultWebsocketRequestHeader,
+  args: defaultWebsocketRequestBody
+}
+
+export interface WebsocketAdapterFetchOptions {
+  cache: boolean
+ }
+
+export interface IWebsocketAdapterMethods extends IAdapter {
+  connect(): Promise<void>;
+  publish(args: Partial<WebsocketRequestBody>): Promise<boolean>;
+  subscribe(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean>;
+  fetch(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean>;
+  unsubscribe(hash?: string): void;
+  unsubscribeAll(): void; 
+  disconnect(): void;
+  terminate(): void;
+
+  abort(): Promise<boolean>;
+
+  handleSetupInternally?: boolean;
+}
+
+export interface IWebsocketAdapter extends IWebsocketAdapterMethods, IAdapter {}
+
+export class WebsocketAdapter extends Adapter implements IWebsocketAdapter {
+  static type = 'WebsocketAdapter';
+  readonly slug: string = 'WebsocketAdapter:unset';
+  private _subscriptions: Set<string> = new Set()
+  private _hashData: Record<string, any> = {}
+
+  private static readonly DEFAULT_RESPONSE_TIMEOUT_MS = 120_000;
+
+  constructor(worker?: Worker | SharedWorker | URL) {
+    super(worker)
+    // StateManager.on('destroy', () => {
+    //   if(this.worker instanceof Worker)
+    //     this.worker?.terminate()
+    // })
+  }
+
+  get worker(): Worker | SharedWorker | undefined {
+    return this.workers?.websocket
+  }
+
+  get subscriptions(): Set<string> {
+    return this._subscriptions
+  }
+
+  async connect(): Promise<void> {}
+  disconnect(): void {}
+  terminate(): void {}
+
+  async publish(args: Partial<WebsocketRequestBody> = defaultWebsocketRequestBody): Promise<boolean> {
+    const pub = this.request({
+      action: 'publish',
+      args: {
+        ...defaultWebsocketRequestBody,
+        ...args
+      }
+    })
+    return this.response(pub) as Promise<boolean>
+  }
+
+  async unsubscribe(hash?: string): Promise<boolean> {
+    if(!hash) return true;
+
+    // Best-effort local cleanup first to avoid leaks/stale subscription state,
+    // even if the worker never acknowledges the unsubscribe.
+    this.subscriptions.delete(hash);
+    try { delete this._hashData[hash]; } catch {}
+
+    // Resolve any in-flight `response()` waiters for this hash.
+    try {
+      StateManager.emit(hash, { type: 'unsubscribed', result: true, hash } as any);
+    } catch {}
+    try {
+      StateManager.off(hash);
+    } catch {}
+
+    // Fire-and-forget worker unsubscribe (worker implementations may not reply).
+    this.request({
+      action: 'unsubscribe',
+      args: {
+        ...defaultWebsocketRequestBody,
+        hash,
+        options: {
+          ...defaultWebsocketAdapterOptions,
+          returnResults: false,
+        },
+      },
+    });
+
+    return true;
+  }
+
+  async unsubscribeAll(hash?: string): Promise<boolean> {
+    const hashes = [...Array.from(this.subscriptions)]
+    for(const hash of hashes){
+      void this.unsubscribe(hash)
+    }
+    return true;
+  }
+
+  async shutdown(): Promise<void> {
+    console.log('WebsocketAdapter:shutdown')
+    // console.log('WebsocketAdapter:shutdown:unsubscribing', this.subscriptions.size)
+    // await this.unsubscribeAll();
+    // console.log('WebsocketAdapter:shutdown:unsubscribed', this.subscriptions.size)
+    // await this.abort();
+    // console.log('WebsocketAdapter:shutdown:aborted')
+    // await delay(1000);
+    this.terminate()
+    console.log('WebsocketAdapter:shutdown:terminated')
+    await delay(100);
+  }
+
+  async abort(): Promise<boolean> {
+    const abort = this.request({
+      action: 'abort',
+      args: { 
+        ...defaultWebsocketRequestBody,
+        hash: 'abort',
+        options: {
+          ...defaultWebsocketAdapterOptions,
+          returnResults: true
+        }
+      }
+    })
+    return this.response(abort) as Promise<boolean>
+  }
+
+  newWorker(): Promise<Worker | SharedWorker> {
+    throw new Error('Method not implemented.');
+  }
+
+  protected bindWorkerHandlers(): void {
+    if(!this?.workers?.websocket) return console.warn('[WebsocketAdapter] Error binding worker handlers: no worker found')
+    if(this.workers.websocket instanceof Worker)
+      this.workers.websocket.onmessage = this._onMessage.bind(this);
+    this.workers.websocket.onerror = this._onError.bind(this)
+  }
+
+  onMessage(response: WebsocketResponseBody): void {
+    const { hash, type, result } = response
+    console.log(`[WebsocketAdapter] onMessage: type=${type}, hash=${hash?.slice(0,8)}, result=`, Array.isArray(result) ? `${result.length} items` : typeof result);
+    StateManager.emit(hash, response)
+  } 
+
+  async subscribe(args: WebsocketRequestBody = defaultWebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean>{
+    let { hash } = args
+    console.log(`[WebsocketAdapter] subscribe called: hash=${hash?.slice(0,8)}, hasWorker=${!!this.worker}`);
+    const hasCallbacks = Boolean(callbacks && Object.keys(callbacks).length > 0);
+    if (hasCallbacks) {
+      args.options.stream = true;
+      // Streamed callbacks require the worker to forward results to the adapter.
+      args.options.returnResults = true;
+    } else {
+      // Without callbacks, stream mode provides no benefit and can hang when
+      // `returnResults=false` (worker won't forward streamed messages).
+      args.options.stream = false;
+    }
+    if (args?.options?.keepAlive && !hasCallbacks) {
+      throw new Error('WebsocketAdapter.subscribe: keepAlive requires callbacks');
+    }
+    console.log(`[WebsocketAdapter] subscribe: calling request()`);
+    const hash_ = this.request({
+      action: 'subscribe',
+      args
+    })
+    console.log(`[WebsocketAdapter] subscribe: request() returned hash=${hash_?.slice(0,8)}`);
+    if(!hash) hash = hash_
+    if(this.subscriptions.has(hash)) {
+      console.warn(`[WebsocketAdapter] Already subscribed to ${hash}`)
+      return true;
+    }
+    this.subscriptions.add(hash)
+    if (args?.options?.keepAlive) {
+      // Do not await completion for keepAlive subscriptions; keep the listener running.
+      this.listen(hash, callbacks);
+      return true;
+    }
+    console.log(`[WebsocketAdapter] subscribe: awaiting response()`);
+    return this.response(hash, callbacks, { timeoutMs: WebsocketAdapter.DEFAULT_RESPONSE_TIMEOUT_MS }) as Promise<IEvent[] | boolean>
+  }
+
+  async fetch(args: WebsocketRequestBody = defaultWebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[] | boolean> {
+    const hasCallbacks = Boolean(callbacks && Object.keys(callbacks).length > 0);
+    if (hasCallbacks) {
+      args.options.stream = true;
+      args.options.returnResults = true;
+    } else {
+      args.options.stream = false;
+    }
+    const hash = this.request({
+      action: 'fetch',
+      args
+    })
+    if(this.subscriptions.has(hash)) {
+      console.warn(`[WebsocketAdapter] Already subscribed to ${hash}`)
+      return true;
+    }
+    this.subscriptions.add(hash)
+    const result = this.response(hash, callbacks, { timeoutMs: WebsocketAdapter.DEFAULT_RESPONSE_TIMEOUT_MS }) as Promise<IEvent[] | boolean> 
+    return result;
+  } 
+
+  setHashData(hash: string, key: string, value: any): void {
+    if(!this._hashData[hash]) this._hashData[hash] = {}
+    this._hashData[hash][key] = value
+  }
+
+  request(message: Partial<WebsocketRequest> = defaultWebsocketRequest): string {
+    if(!message?.args) throw new Error('No args found in message')
+    if(!message?.args?.hash) {
+      message.args.hash = deterministicHash(message?.args?.filters ?? {})
+    }
+    const { hash } = message.args
+    console.log(`[WebsocketAdapter] request: action=${message?.action}, hash=${hash?.slice(0,8)}, workerExists=${!!this?.worker}`);
+    if(!this?.worker) {
+      console.warn('[WebsocketAdapter] Error sending command: no worker found')
+      return hash
+    }
+    if(this.worker instanceof Worker) {
+      console.log(`[WebsocketAdapter] request: posting to Worker`);
+      this.worker.postMessage(message)
+    } else if(this.worker instanceof SharedWorker) {
+      console.log(`[WebsocketAdapter] request: posting to SharedWorker`);
+      this.worker.port.postMessage(message)
+    }
+    return hash
+  }
+
+  private listen(hash: string, callbacks?: SubscribeHandlers): void {
+    const responseHandler = (message: WebsocketResponseBody) => {
+      let { result, type } = message
+      if(type === 'events') {
+        if(callbacks?.onevents){
+          callbacks.onevents(result)
+          return
+        }
+        for(let event of result){
+          callbacks?.onevent?.(event)
+        }
+      }
+      else if(type === 'event'){
+        callbacks?.onevent?.(result)
+      }
+      else if(type === 'complete'){
+        // Call oneose when complete is received (EOSE from relay)
+        callbacks?.oneose?.();
+        this.subscriptions.delete(hash)
+        try { delete this._hashData[hash]; } catch {}
+        StateManager.off(hash)
+        callbacks?.onclose?.(hash)
+      }
+      else if(type === 'unsubscribed' || type === 'aborted' || type === 'terminated'){
+        this.subscriptions.delete(hash)
+        try { delete this._hashData[hash]; } catch {}
+        StateManager.off(hash)
+        callbacks?.onclose?.(hash)
+      }
+      else {
+        console.warn(`[WebsocketAdapter] Unknown response type: ${type}`)
+      }
+    }
+    StateManager.on(hash, responseHandler)
+  }
+
+  async response(
+    hash: string,
+    callbacks?: SubscribeHandlers,
+    options?: { timeoutMs?: number }
+  ): Promise<boolean | any[]>{
+    const timeoutMs = options?.timeoutMs;
+    return new Promise( (resolve) => {
+      const results: any[] = []
+      let resolved = false;
+      let timeout: ReturnType<typeof setTimeout> | null = null;
+
+      const finish = (value: boolean | any[]) => {
+        if(resolved) return;
+        resolved = true;
+        if(timeout) clearTimeout(timeout)
+        cleanup();
+        resolve(value)
+      }
+
+      const responseHandler = (message: WebsocketResponseBody) => {
+        let { result, type } = message
+        if(type === 'unsubscribed' || type === 'aborted' || type === 'terminated'){
+          callbacks?.onclose?.(hash)
+          return finish(true)
+        }
+        if(type === 'events') {
+          if(callbacks?.onevents){
+            callbacks.onevents(result)
+            return
+          }
+          for(let event of result){
+            if(callbacks?.onevent){
+              callbacks.onevent(event)
+            }
+            else {
+              results.push(event)
+            }
+          }
+        }
+        else if(type === 'event'){
+          if(callbacks?.onevent){
+            callbacks.onevent(result)
+          }
+          else {
+            results.push(result)  
+          }
+        }
+        else if(type == 'complete'){
+          // Call oneose when complete is received (EOSE from relay)
+          callbacks?.oneose?.();
+          if(callbacks?.onevent){
+            return finish(true)
+          }
+          else if(results){
+            return finish(results)
+          }
+        }
+        else {
+          console.warn(`[WebsocketAdapter] Unknown response type: ${type}`)
+        }
+      }
+
+      const cleanup = () => {
+        this.subscriptions.delete(hash)
+        try { delete this._hashData[hash]; } catch {}
+        try {
+          StateManager.off(hash, responseHandler as any)
+        } catch {
+          try { StateManager.off(hash) } catch {}
+        }
+      }
+
+      if(typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0) {
+        timeout = setTimeout(() => {
+          if(callbacks?.onevent || callbacks?.onevents) {
+            finish(true)
+          }
+          else {
+            finish(results)
+          }
+        }, timeoutMs)
+      }
+      StateManager.on(hash, responseHandler)
+    });
+  }
+
+  ping(): void {
+    if(this.worker instanceof Worker) {
+      (this.workers?.websocket as Worker)?.postMessage({type: 'ping'})
+    }
+    else if(this.worker instanceof SharedWorker) {
+      (this.workers?.websocket as SharedWorker)?.port.postMessage({type: 'ping'})
+    }
+      
+  }
+  
+}

package/src/core/Workers.ts

@@ -0,0 +1,115 @@
+import { IAdaptersArgument } from '@base/interfaces/IAdaptersArgument';
+import { IEvent } from '@models/Event';
+
+
+export class Workers {
+  private _websocketShared?: SharedWorker;
+  private _cacheShared?: SharedWorker;
+
+  private _channel: MessageChannel = new MessageChannel();
+
+  private _websocket?: Worker | SharedWorker;
+  private _cache?: Worker | SharedWorker;
+
+  private _ready: boolean = false;
+
+  constructor( adapters: IAdaptersArgument, private doSetup: boolean = true ){
+    this.setupWorkers( adapters )
+  }
+
+  get ready(): boolean {
+    return this._ready;
+  }
+
+  get websocketWorkers(): Partial<Workers> {
+    const { websocket, channel } = this;
+    return { websocket, channel };
+  }
+
+  get cacheWorkers(): Partial<Workers> {
+    const { cache, channel } = this;
+    return { cache, channel };
+  }
+
+  get websocket(): Worker | SharedWorker | undefined {
+    return this._websocket;
+  }
+
+  set websocket(worker: Worker | SharedWorker | undefined){
+    this._websocket = worker;
+  }
+
+  get cache(): Worker | SharedWorker | undefined {
+    return this._cache;
+  }
+
+  set cache(worker: Worker | SharedWorker | undefined){
+    this._cache = worker;
+  }
+
+  get channel(): MessageChannel {
+    return this._channel;
+  }
+
+  async setupWorkers(adapters: IAdaptersArgument){
+    const cacheAdapterChannelPort = this.channel.port2;
+    const websocketAdapterChannelPort = this.channel.port1;
+
+    if(adapters.cacheAdapter.useWorker){
+      this.cache = (await adapters.cacheAdapter.newWorker(cacheAdapterChannelPort)) as Worker | SharedWorker
+      ////console.log('cacheAdapter.newWorker()', this.cache)
+    }
+    if(adapters.websocketAdapter.useWorker){
+      this.websocket = (await adapters.websocketAdapter.newWorker(websocketAdapterChannelPort)) as Worker | SharedWorker
+      ////console.log('websocketAdapter.newWorker()', this.websocket)
+    }
+    if(adapters.cacheAdapter.useWorker && adapters.websocketAdapter.useWorker){
+      if(!adapters.cacheAdapter.handleSetupInternally && (this.cache instanceof Worker || this.cache instanceof SharedWorker)){
+        const message = {type: 'setup', channelPort: cacheAdapterChannelPort}
+        if(this.cache instanceof Worker) {
+          ////console.log(`[Workers] setupWorkers() -> cache.postMessage() to Worker`, this.cache, message)
+          this.cache.postMessage(message, [cacheAdapterChannelPort]);  
+        }
+        else if (this.cache instanceof SharedWorker) {
+          ////console.log(`[Workers] setupWorkers() -> cache.port.postMessage() to SharedWorker`, this.cache, message)
+          this.cache.port.postMessage(message, [cacheAdapterChannelPort]);
+        }
+        
+      }
+      else {
+        console.warn('Cache Worker not defined')
+      }
+      if(!adapters.websocketAdapter.handleSetupInternally && (this.websocket instanceof Worker || this.websocket instanceof SharedWorker)){
+        const message = {type: 'setup', channelPort: websocketAdapterChannelPort}
+        if(this.websocket instanceof Worker) {
+          ////console.log(`[Workers] setupWorkers() [websocket] -> websocket.postMessage() to Worker`, message)
+          this.websocket.postMessage(message, [websocketAdapterChannelPort]);
+        }
+        else if(this.websocket instanceof SharedWorker) {
+          ////console.log(`[Workers] setupWorkers() [websocket] -> websocket.port.postMessage() to SharedWorker`, message)
+          this.websocket.port.postMessage(message, [websocketAdapterChannelPort]);
+        }
+      }
+      else {
+        console.warn('Websocket Worker not defined')
+      }
+    }
+    this._ready = true;
+  }
+
+  static encodeNostrEventArrayAsBuffer (json: IEvent[] | IEvent): ArrayBuffer {
+    if(json instanceof ArrayBuffer) return json as unknown as ArrayBuffer;
+    const jsonString = JSON.stringify(json);
+    const encoder = new TextEncoder();
+    const uint8Array = encoder.encode(jsonString);
+    return uint8Array.buffer; 
+  }
+
+  static decodeNostrEventArrayFromBuffer (arrayBuffer: ArrayBuffer): IEvent[] | IEvent {
+    if(!(arrayBuffer instanceof ArrayBuffer)) return arrayBuffer as IEvent[] | IEvent;
+    const decoder = new TextDecoder();
+    const jsonString = decoder.decode(new Uint8Array(arrayBuffer));
+    const nostrEvents: IEvent[] | IEvent = JSON.parse(jsonString)
+    return nostrEvents;
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,15 @@
+export * from './Adapter'
+export * from './AdapterCacheWorker';
+export * from './AdapterWebsocketWorker';
+export * from './AdapterWorker';
+
+export * from './Base';
+export * from './Batcher';
+export * from './CacheAdapter'
+
+export * from './Workers';
+export * from './Queue';
+
+export * from './WebsocketAdapter';
+
+export * from './Batcher';

package/src/factory/cache.shared.worker.ts

@@ -0,0 +1,14 @@
+import { ICacheAdapterSharedWorkerCommand } from '@interfaces/ICacheAdapterSharedWorkerCommand';
+
+export default (_AdapterSharedWorker_: any) => {
+  return async (event: MessageEvent) => {
+    const mainThread = event.ports[0];
+    const sharedWorker = new _AdapterSharedWorker_( { mainThread } );
+    await sharedWorker.init();
+    mainThread.onmessage = function(message: MessageEvent) {
+      const command = message.data as ICacheAdapterSharedWorkerCommand;
+      sharedWorker.onMessage(command);
+    };
+    mainThread.onmessageerror = sharedWorker.onMessageError;
+  };
+}

package/src/factory/cache.worker.ts

@@ -0,0 +1,13 @@
+import { AdapterWorker } from '@base/core';
+import type { ISharedWorkerGlobalScope, IWorkerGlobalScope } from '@interfaces/index';
+import type { IAdapterWorkerCommand } from '@interfaces/IAdapterWorkerCommand';
+
+export interface ICacheAdapterWorker {
+  onMessage: (command: IAdapterWorkerCommand) => void;
+  onError: (error: any) => void;
+  onMessageError: (error: any) => void;
+}
+
+export default (_AdapterWorker_: typeof AdapterWorker, mainThread: IWorkerGlobalScope | ISharedWorkerGlobalScope): any  => {
+  return new _AdapterWorker_( { mainThread } );
+}

package/src/factory/index.ts

@@ -0,0 +1,2 @@
+export { default as CacheSharedWorker } from './cache.shared.worker';  
+export { default as CacheWorker, ICacheAdapterWorker } from './cache.worker';

package/src/helpers/filters.ts

@@ -0,0 +1,9 @@
+import { Filter } from "nostr-tools";
+
+export const searchRelayFilter = (): Filter => {
+    return { "#N": [ "50" ] }
+}
+
+export const communityFilter = (): Filter => {
+    return { "#N": [ "29" ] }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+import Base from './core/Base';
+
+export { StateManager } from './managers/StateManager';
+export { CacheAdapter, type ICacheAdapter, type GeohashOptions } from './core/CacheAdapter';
+export { MonitorManager, type MonitorPriorities, type MonitorPriority } from './managers/MonitorManager';
+export * from './factory/cache.shared.worker';
+export type * from './interfaces/index';
+export { Service } from './services/Service';
+export { ChronicleService, type ChronicleServiceOptions, type TimeSeriesOptions, type UptimePeriod } from './services/ChronicleService';
+
+export { Base as Route66 };
+
+export default Base;

package/src/interfaces/IAdapterWorkerCommand.ts

@@ -0,0 +1,8 @@
+import { ISharedWorkerGlobalScope } from "./ISharedWorkerGlobalScope";
+import { IWorkerCommand } from "./IWorkerCommand";
+import { IWorkerGlobalScope } from "./IWorkerGlobalScope";
+
+export interface IAdapterWorkerCommand extends IWorkerCommand {
+  channelPort?: MessagePort
+  mainThread?: IWorkerGlobalScope | ISharedWorkerGlobalScope;
+}

package/src/interfaces/IAdaptersArgument.ts

@@ -0,0 +1,7 @@
+import { ICacheAdapter } from '@base/core/CacheAdapter';
+import { IWebsocketAdapter } from '@base/core/WebsocketAdapter';
+
+export interface IAdaptersArgument {
+  cacheAdapter: ICacheAdapter;
+  websocketAdapter: IWebsocketAdapter;
+}

package/src/interfaces/ICacheAdapter.ts

@@ -0,0 +1,42 @@
+// // src/interfaces/ICacheAdapter.ts
+
+// import { Event } from '../models/IEvent';
+// import { Monitor } from '../models/Monitor';
+// import { IAdapter } from './IAdapter';
+
+// export interface GeohashOptions {
+//   maxDistance?: number; 
+// }
+
+// export interface ICacheAdapter extends IAdapter {
+
+//   // Basic CRUD operations for events
+//   getEvent(id: string): Promise<Event | null>;
+//   setEvent(id: string, event: Event): Promise<void>;
+//   deleteEvent(id: string): Promise<void>;
+//   clearEvents(): Promise<void>;
+
+//   // Basic CRUD operations for monitors
+//   getMonitor(id: string): Promise<Monitor | null>;
+//   setMonitor(monitor: Monitor): Promise<void>;
+//   deleteMonitor(id: string): Promise<void>;
+//   clearMonitors(): Promise<void>;
+
+//   // Basic CRUD operations for relays
+//   getRelay(id: string): Promise<any | null>;
+//   deleteRelay(id: string): Promise<void>;
+//   clearRelays(): Promise<void>;
+
+//   // NIP-66 Specific Query Methods
+//   findMonitorsByGeohash(geohash: string, options?: GeohashOptions): Promise<Monitor[]>;
+//   sortMonitorsByDistance(geohash: string): Promise<Monitor[]>;
+//   findMonitorsByChecks(checks: string[]): Promise<Monitor[]>;
+//   findRelaysByNIPs(nips: string[], condition: 'AND' | 'OR'): Promise<any[]>;
+//   findRelaysByISP(isp: string): Promise<any[]>;
+//   findRelaysByIP(ip: string): Promise<any[]>;
+//   findRelaysByCountryCode(countryCode: string): Promise<any[]>;
+//   findRelaysByOwner(ownerPubkey: string): Promise<any[]>;
+//   findRelaysByNetwork(network: string): Promise<any[]>;
+//   findRelaysByRTTOpen(rttOpen: number): Promise<any[]>;
+//   findRelaysByLiveness(livenessStatus: 'online' | 'offline' | 'dead'): Promise<any[]>;
+// }