@nostrwatch/route66 0.0.1

package/src/services/RelayService.ts

@@ -0,0 +1,250 @@
+import { IWebsocketAdapter, SubscribeHandlers, WebsocketAdapterOptions } from '@core/WebsocketAdapter';
+import { ICacheAdapter } from '@core/CacheAdapter';
+import { IAdaptersArgument } from '@interfaces/IAdaptersArgument';
+import { EventEmitter } from 'tseep';
+import { Service } from './Service';
+import { StateManager } from '@base/managers/StateManager';
+import { IEvent } from '@base/interfaces';
+import { Filter } from 'nostr-tools';
+import { Monitor, Nip66CheckEvent, NostrEvent } from '@base/models';
+import { MonitorService } from './MonitorService';
+import { getNormalizedWebsocketVariants, WebsocketUrlType } from '@base/utils/nostr';
+
+export class RelayService extends Service {
+  monitors: MonitorService;
+  private _relay: string = '';
+  protected _ready: boolean = false;
+
+  constructor( adapters: IAdaptersArgument, monitorService?: MonitorService ) {
+    super(adapters)
+    this.monitors = monitorService ?? new MonitorService(adapters);
+
+    //TODO: Move these to a defaults method in Services that can be used for convenience. 
+    //The default relays should be loaded from a config or note.
+    this.addRelay('route66', 'wss://relay.nostr.watch');
+    this.addRelay('route66', 'wss://relaypag.es');
+    this.addRelay('route66', 'wss://monitorlizard.nostr1.com/')
+    this.addRelay('userMeta', 'wss://purplepag.es');
+    this.addRelay('userMeta', 'wss://user.kindpag.es');
+    this.addRelay('userMeta', 'wss://relay.nostr.band');
+    this.init()
+  }
+
+  async init(): Promise<void> {
+    await this?.cacheAdapter?.ready();
+    await this?.monitors?.ready();
+    this._ready = true;
+  }
+
+  async ready(): Promise<void> {
+    while(!this._ready){
+      await new Promise(resolve => setTimeout(resolve, 100))
+    }
+  }
+
+  relayFilters(relay: WebsocketUrlType, liveness: string = 'online'): Filter[] { 
+    const filters: Filter[] = []
+    // console.log('this.monitors.activeMonitors', liveness, this.monitors.activeMonitors.length)
+    if( this.monitors.activeMonitors.length === 0 ) return [{ kinds: [30166], "#d": [relay] }]
+    const monitors = liveness === 'online'? this.monitors.activeMonitors: this.monitors.array;
+    const defaultFilter: Filter = { "#d": getNormalizedWebsocketVariants(relay), kinds: [30166] }
+    if(liveness === 'dead') {
+      // console.log('relayfilters', filters)
+      return [defaultFilter]
+    }
+    monitors.forEach((monitor) => {
+      let filter;
+      switch(liveness){
+        case 'offline':
+          filter = { ...monitor.checkFilterOffline, ...defaultFilter }
+          break;
+        case 'online': 
+          filter = { ...monitor.checkFilter, ...defaultFilter }
+      }
+      if(!filter) return;
+      filters.push(filter)
+    })
+    // console.log('relayfilters', filters)
+    return filters;
+  }
+
+  /**
+   * Create filters for Kind 1066 delta events for a relay
+   * Used for querying relay history and time series data
+   *
+   * @param relay - Relay URL to create filters for
+   * @param options - Optional filter parameters
+   * @returns Array of filters for Kind 1066 events
+   */
+  deltaFilters(relay: WebsocketUrlType, options?: { since?: number; until?: number; limit?: number }): Filter[] {
+    const filter: Filter = {
+      kinds: [1066],
+      '#r': getNormalizedWebsocketVariants(relay),
+    };
+
+    if (options?.since) {
+      filter.since = options.since;
+    }
+
+    if (options?.until) {
+      filter.until = options.until;
+    }
+
+    if (options?.limit) {
+      filter.limit = options.limit;
+    }
+
+    return [filter];
+  }
+
+  async getRelayData(relay: string, liveness: string = 'online'): Promise<[ Nip66CheckEvent[], Map<string, Monitor> ] | undefined> {
+    await this.ready();
+    await this.monitors.ready();
+    let checks = await this.fetchRelayChecks(relay, liveness);
+    if(!checks || !checks?.length) return;
+    const monitors: Map<string, Monitor> | undefined = (await this.monitorInstancesFromChecks(checks)) as Map<string, Monitor>;
+    if(!monitors) return;
+    if(liveness === 'online') {
+      checks = checks.filter(check => {
+        const monitor = monitors.get(check.pubkey);
+        if(!monitor || !monitor.relayIsOnline(check)) return false
+        return true
+      })
+    }
+    if(liveness === 'offline') {
+      checks = checks.filter(check => {
+        const monitor = monitors.get(check.pubkey);
+        if(!monitor || !monitor.relayIsOffline(check, true)) return false
+        return true
+      })
+    }
+    if(liveness === 'dead') {
+      checks = checks.filter(check => {
+        const monitor = monitors.get(check.pubkey);
+        if(!monitor || !monitor.relayIsDead(check)) return false
+        return true
+      })
+    }
+    return [ checks, monitors ];
+  }
+
+  async fetchRelayChecks(r: string, liveness: string = 'online'): Promise<Nip66CheckEvent[] | undefined> {
+    const relay: string | null = RelayService.formatRelay(r);
+    if(!relay) return;
+    const filters: Filter[] = this.relayFilters(relay as WebsocketUrlType, liveness);
+    const relays = this.nip66Relays;
+    const priority = 100;
+    const options: WebsocketAdapterOptions = {
+      cache: true,
+      returnResults: true, 
+      keepAlive: false,
+      stream: false
+    }
+    const events: IEvent[] = await this.fetch( { relays, filters, options, hash: `relay:${Math.random()}`, priority } );
+    if(!events) return;
+    const checks: Nip66CheckEvent[] = events.map((event: IEvent) => new Nip66CheckEvent(event));  
+    return checks;
+  }
+
+  async fetchOperatorMeta(pubkey: string, callbacks?: SubscribeHandlers, relays: string[] = []): Promise<IEvent[]> {
+    const filters: Filter[] = [
+      { kinds: [0, 10002], authors: [pubkey] }
+    ]
+    relays = [...this.userMetaRelays, ...relays];
+    const priority = 1000;
+    const options: WebsocketAdapterOptions = {
+      cache: true,
+      returnResults: true, 
+      keepAlive: false,
+      stream: true,
+      batch: 1
+    }
+    return this.subscribe( { relays, filters, priority, options }, callbacks );
+  }
+
+  async monitorInstancesFromChecks(checks: Nip66CheckEvent[], type: 'map' | 'array' = 'map'): Promise<Map<string, Monitor> | Monitor[] | undefined> {
+    let filters: Filter[] = []
+    const metaPromises: Promise<any>[] = []
+    for(const check of checks){
+      filters.push({ authors: [check.pubkey], kinds: [10166] })
+    }
+    let relays = [...this.nip66Relays];
+    const options: WebsocketAdapterOptions = {
+      cache: true,
+      returnResults: true, 
+      keepAlive: false,
+      stream: true,
+      batch: 1
+    }
+    const monitorsProcessed = new Set()
+    const onevent = (event: IEvent) => {
+      this.monitors.manager.handleEvent(event)
+      if(event.kind === 10166) {
+        if(monitorsProcessed.has(event.pubkey)) return;
+        metaPromises.push(this.monitors.fetch(
+          { 
+            relays: [...this.userMetaRelays], 
+            filters: [{ authors: [event.pubkey], kinds: [0, 10002] }], 
+            options 
+          }, 
+          { onevent }
+        ))
+        monitorsProcessed.add(event.pubkey)
+      }  
+    }
+    await this.monitors.subscribe( 
+      { relays, filters, options },
+      { onevent }
+    )
+    await Promise.allSettled(metaPromises)
+    return type === 'map'? this.monitors.map: this.monitors.array
+  }
+
+  static formatRelay(relay: string): string | null { 
+    try {
+      return new URL(relay).toString();
+    }
+    catch {
+      console.warn (`[RelayService] Invalid relay URL: ${relay}`);
+      return '';
+    }
+  }
+
+  static removeOldChecks (monitors: Map<string, Monitor>, checks: Nip66CheckEvent[]): Nip66CheckEvent[] {
+    return checks.filter(check => {
+      const monitor = monitors.get(check.pubkey);
+      if(monitor && monitor.relayIsOnline(check)) return true
+      return false
+    })
+  }
+
+  async beginLiveSync(relay: string, callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    const filters: Filter[] = []
+    this.monitors.enabledMonitors.forEach( (monitor: Monitor ) => {
+      const lastSyncUntil = monitor.getLastSync(30166)?.until;
+      filters.push({ 
+        kinds: [30166], 
+        authors: [monitor.pubkey], 
+        since: lastSyncUntil, 
+        "#d": [relay] 
+      });
+    }) 
+    const hash = `liveSyncMonitorsChecksForRelay`;
+    const relays: string[] = this.nip66Relays;
+    const options: WebsocketAdapterOptions = {
+      cache: true,
+      keepAlive: true,
+      returnResults: true,
+      stream: true,
+      batch: 2
+    }
+    const onevents: SubscribeHandlers['onevents'] = (events: IEvent[]) => {  
+      callbacks?.onevents?.(events);
+    };
+    return this.subscribe({ filters, relays, options, hash }, { onevents });
+  }
+
+  async stopLiveSync(): Promise<void> {
+    await this.unsubscribe('liveSyncMonitorsChecksForRelay');
+  }
+}

package/src/services/Service.ts

@@ -0,0 +1,370 @@
+import { IEvent } from "@base/interfaces";
+import type { ICacheAdapter, IWebsocketAdapter, SubscribeHandlers, WebsocketRequestBody,  WebsocketAdapterOptions } from "@base/core";
+import { defaultWebsocketAdapterOptions } from "@base/core";
+import { IAdaptersArgument } from "@base/interfaces/IAdaptersArgument";
+import { Filter } from "nostr-tools";
+import { deterministicHash, isPRE, isRE } from "@base/utils";
+import { StateManager } from "@base/managers/StateManager";
+import { NostrEvent } from "@base/models";
+import { SOURCE } from "@base/models/Event";
+
+export interface IGroupedRelays {
+  userMeta?: string[];
+  route66?: string[];
+  appData?: string[];
+}
+
+// export interface WebsocketRequestBody extends WebsocketRequestBody {}
+
+export type ServiceAdaptersTypes = {
+  cache: ICacheAdapter;
+  websocket: IWebsocketAdapter;
+}
+
+export class Service {
+  protected cacheAdapter: ICacheAdapter;
+  protected websocketAdapter: IWebsocketAdapter;
+  protected _groupedRelays: IGroupedRelays = {};
+  protected _ready: boolean = false;
+  protected _subscriptions: Set<string> = new Set();
+
+  constructor(adapters: IAdaptersArgument) {
+    this.cacheAdapter = adapters.cacheAdapter;
+    this.websocketAdapter = adapters.websocketAdapter;
+  }
+
+  get adapter(): ServiceAdaptersTypes {
+    return { cache: this.cacheAdapter, websocket: this.websocketAdapter };
+  }
+
+  get nip66Relays(): string[] {
+    return this._groupedRelays?.route66 || [];
+  }
+
+  get userMetaRelays(): string[]{
+    return this._groupedRelays?.userMeta || [];
+  }
+
+  get subscriptions(): Set<string> {
+    return this._subscriptions;
+  }
+
+  async ready(): Promise<void> {
+    while (!this._ready) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
+  async modifyCacheFilters(filters: Filter[]): Promise<Filter[]> {
+    console.warn('modifyCacheFilters not implemented');
+    return filters;
+  }
+
+  async modifyWebsocketFilters(filters: Filter[]): Promise<Filter[]> {
+    console.warn('modifyWebsocketFilters not implemented');
+    return filters;
+  }
+
+  async publish(args: WebsocketRequestBody): Promise<boolean> {
+    await this.ready();
+    let { hash, note, relays } = args
+    if(!note) return false;
+    if(!hash) {
+      hash = note.id.slice(0, 21)
+    }
+    this.subscriptions.add(hash)
+    await this.websocketAdapter.publish({ note, relays, hash });
+    this.subscriptions.delete(hash)
+    return false;
+  }
+
+  async subscribe(args: WebsocketRequestBody, callbacks?: SubscribeHandlers, nocache: boolean = false): Promise<IEvent[]> {
+    await this.ready();
+    let { filters, relays, options, hash } = args;
+    if(!hash) {
+      hash = deterministicHash(args)
+    }
+    args.hash = hash;
+    this.subscriptions.add(hash)
+
+    console.log(`[Service] subscribe: hash=${hash?.slice(0,8)}, nocache=${nocache}, stream=${options?.stream}, keepAlive=${options?.keepAlive}, adapterType=${this.websocketAdapter?.constructor?.name}`);
+
+    let result: IEvent[] = [];
+
+    const hasCallbacks = Boolean(callbacks && Object.keys(callbacks).length > 0);
+    console.log(`[Service] subscribe: hasCallbacks=${hasCallbacks}`);
+
+    if(filters && !nocache) {
+      let cacheCallbacks: SubscribeHandlers = {}
+      if(callbacks) {
+        cacheCallbacks = this.addSymbolToCallbacks(callbacks, 'cache');
+        this.fetchFromCache(filters, cacheCallbacks);
+      }
+      else {
+        result = this.addSymbolToEvents(await this.fetchFromCache(filters), 'cache');
+      }
+    }
+
+    let wsCallbacks: SubscribeHandlers | undefined = undefined;
+    if(hasCallbacks && callbacks) {
+      const originalOnclose = callbacks.onclose;
+      const wrappedCallbacks: SubscribeHandlers = {
+        ...callbacks,
+        onclose: (subId: string) => {
+          this.subscriptions.delete(subId)
+          originalOnclose?.(subId)
+        }
+      }
+      wsCallbacks = this.addSymbolToCallbacks(wrappedCallbacks, 'ws');
+    }
+
+    const shouldStream = Boolean(options?.stream === true && hasCallbacks);
+    console.log(`[Service] subscribe: shouldStream=${shouldStream}`);
+    if(shouldStream){
+      console.log(`[Service] subscribe: calling websocketAdapter.subscribe, subscribeIsFn=${typeof this.websocketAdapter?.subscribe === 'function'}`);
+      if(options?.keepAlive){
+        void this.websocketAdapter.subscribe(args, wsCallbacks);
+      }
+      else {
+        try {
+          await this.websocketAdapter.subscribe(args, wsCallbacks);
+        } catch (err) {
+          console.error(`[Service] subscribe error:`, err);
+          throw err;
+        }
+      }
+      console.log(`[Service] subscribe: websocketAdapter.subscribe returned`);
+    }
+    else {
+      // Stream subscriptions without callbacks can hang (worker won't forward streamed messages
+      // when `returnResults=false`). Force non-stream behavior when no callbacks are present.
+      console.log(`[Service] subscribe: using _fetch instead of websocket subscribe`);
+      args.options = { ...defaultWebsocketAdapterOptions, ...(options ?? {}), stream: false };
+      result = this.addSymbolToEvents(await this._fetch(args, wsCallbacks), 'ws');
+    }
+    if(!options?.keepAlive) {
+      this.subscriptions.delete(hash)
+    }
+
+    return shouldStream ? [] : result;
+  }
+
+  subscribeRelatives(note: IEvent | NostrEvent, relays?: string[], callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    const { id } = note
+    const filters: Filter[] = [
+        { kinds: [9735, 9321], '#e': [id] },  //zaps
+        { kinds: [1, 7, 1111], '#e': [id] },  //commments, mentions
+        { kinds: [1111], '#E': [id] }         //NIP-22 comments
+    ]
+    relays = [ ...(relays || []), 'wss://relay.damus.io' ]
+    const options: WebsocketAdapterOptions  = {
+        cache: true,
+        stream: true,
+        returnResults: true,
+        keepAlive: false
+    }
+    const args: WebsocketRequestBody = {
+        filters,
+        relays,
+        options,
+        priority: 5
+    }
+    return this.subscribe(args, callbacks) as Promise<IEvent[]>
+  }
+
+  private addSymbolToCallbacks(callbacks: SubscribeHandlers, symbolValue: string): SubscribeHandlers {
+    const newCallbacks = {...callbacks}
+    newCallbacks.onevent = (event: IEvent) => {
+      event[SOURCE] = symbolValue
+      callbacks.onevent?.(event)
+    }
+    newCallbacks.onevents = (events: IEvent[]) => {
+      events = events.map( event => {
+        event[SOURCE] = symbolValue
+        return event
+      })
+      callbacks.onevents?.(events)
+    }
+    return newCallbacks;
+  }
+
+  private addSymbolToEvents(events: IEvent[], symbolValue: string): IEvent[] {
+    return events.map( event => {
+      event[SOURCE] = symbolValue
+      return event
+    })
+  }
+
+  async unsubscribe(hash: string) {
+    await this.ready();
+    this.websocketAdapter.unsubscribe(hash);
+  }
+
+  async unsubscribeMany(hashes: string[]) {
+    await this.ready();
+    hashes.forEach((hash) => {
+      this.unsubscribe(hash);
+    })
+  }
+
+  async unsubscribeAllActive(){
+    await this.ready();
+    this.subscriptions.forEach((hash) => {
+      this.unsubscribe(hash);
+    })
+  }
+
+  async unsubscribeAll(){
+    await this.ready();
+    this.websocketAdapter.unsubscribeAll();
+  }
+
+  async fetch(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    await this.ready();
+    if(!args.hash) {  
+      args.hash = deterministicHash(args);
+    }
+    this.subscriptions.add(args.hash)
+    const results = await this._fetch(args, callbacks);
+    this.subscriptions.delete(args.hash)
+    return results;
+  }
+
+  async countFromCache(filters: Filter[]): Promise<number> {
+    await this.ready();
+    return this.cacheAdapter.COUNT(filters);
+  }
+
+  async fetchFromCache(filters: Filter[], callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    await this.ready();
+    let cacheEvents: IEvent[] = [];
+    cacheEvents = await this.cacheAdapter.REQ(filters);
+    if(cacheEvents?.length){
+      // StateManager.emit('events', cacheEvents);
+      if (callbacks?.onevents) {
+        callbacks.onevents(cacheEvents);
+      }
+      if (callbacks?.onevent) {
+        cacheEvents.forEach(event => {
+          callbacks.onevent?.(event);
+        });
+      }
+  
+    }
+    return cacheEvents?.length? cacheEvents: [];
+  }
+
+  async fetchFromWebsocket(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    await this.ready();
+    // console.log('Service.fetchFromWebsocket: ready', args);
+    const { relays, filters, options, hash } = args;
+    const websocketEvents: IEvent[] = await this.websocketAdapter.fetch(
+        {
+            relays: relays || [],
+            filters,
+            options: options || defaultWebsocketAdapterOptions,
+            hash,
+        },
+        callbacks
+    ) as IEvent[];
+    if(websocketEvents instanceof Array){
+      StateManager.emit('events', websocketEvents);
+    }
+    return websocketEvents instanceof Array ? websocketEvents : [];
+  }
+
+  async _fetch(args: WebsocketRequestBody, callbacks?: SubscribeHandlers): Promise<IEvent[]> {
+    await this.ready();
+    const { relays, options } = args;
+    let { filters } = args;
+    let { returnResults } = options;
+
+    filters = filters ?? [];
+
+    const events = new Map<string, IEvent>();
+
+    const generateId = (event: IEvent): string | undefined => {
+        if (isPRE(event)) {
+            const dtagv = event.tags.find((t: string[]) => t[0] === 'd')?.[1];
+            return dtagv ? `${event.pubkey}:${event.kind}:${dtagv}` : undefined;
+        }
+        return isRE(event) ? `${event.pubkey}:${event.kind}` : event.id;
+    };
+
+    const maybeAddEventToMap = (event: IEvent): boolean => {
+        const id = generateId(event);
+        if (!id || events.has(id)) return false;
+        events.set(id, event);
+        return true;
+    };
+
+    const cacheEvents = await this.fetchFromCache(filters, callbacks);
+
+    if(cacheEvents.length > 0) {
+      cacheEvents.forEach(maybeAddEventToMap);
+    }
+
+    const _callbacks: SubscribeHandlers = {};
+
+    if (callbacks?.onevent) {
+      _callbacks.onevent = (event: IEvent) => {
+          if (maybeAddEventToMap(event)) callbacks.onevent!(event);
+      };
+    }
+
+    if (callbacks?.onevents) {
+        StateManager.emit('events', cacheEvents);
+        _callbacks.onevents = (batch: IEvent[]) => {
+            const newEvents: IEvent[] = [];
+            for (const event of batch) {
+                if (maybeAddEventToMap(event)) newEvents.push(event);
+            }
+            if (newEvents.length > 0) callbacks.onevents!(newEvents);
+        };
+    }
+
+    const websocketEvents = await this.fetchFromWebsocket(args, _callbacks);
+    websocketEvents.forEach(maybeAddEventToMap);
+
+    if(Object.keys(_callbacks).length === 0) {
+      StateManager.emit('events', websocketEvents);
+    }
+
+    const finalEvents = Array.from(events.values());
+    return this.modifyReturnedEvents(finalEvents);
+  }
+
+  async modifyReturnedEvents(events: IEvent[]): Promise<IEvent[]> {
+    console.warn('modifyReturnedEvents not implemented');
+    return events;
+  }
+
+  addRelay(to: keyof IGroupedRelays, relay: string): void {
+    if (!this._groupedRelays?.[to]) this._groupedRelays[to] = [];
+    this._groupedRelays?.[to].push(relay);
+  }
+
+  removeRelay(from: keyof IGroupedRelays, relay: string): void {
+    if (!this._groupedRelays?.[from]) return;
+    this._groupedRelays[from] = this._groupedRelays[from].filter((r) => r !== relay);
+  }
+
+  /**
+   * Replace all relays in a group with new ones
+   * Note: Empty arrays are ignored to prevent accidentally wiping out relay lists
+   */
+  setRelays(group: keyof IGroupedRelays, relays: string[]): void {
+    if (!relays || relays.length === 0) {
+      console.warn(`setRelays called with empty array for group '${group}', ignoring`);
+      return;
+    }
+    this._groupedRelays[group] = [...relays];
+  }
+
+  /**
+   * Clear all relays from a group
+   */
+  clearRelays(group: keyof IGroupedRelays): void {
+    this._groupedRelays[group] = [];
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,5 @@
+export * from './MonitorService';
+export * from './RelayService';
+export * from './AuditorService';
+export * from './Service';
+export * from './ChronicleService';

package/src/transform/TransformCheck.ts

@@ -0,0 +1,62 @@
+import { NostrTag } from "@base/models/Event";
+
+export const transformCheck = (event: any) => {
+    const nid = event.id;
+    
+    const dTag = event.tags.find((tag: NostrTag) => tag[0] === 'd');
+    const relay = dTag ? new URL(dTag[1]).toString() : null;
+  
+    const monitorPubkey = event.pubkey;
+    const created_at = event.created_at;
+  
+    const networks = event.tags.find((tag: NostrTag) => tag[0] === 'n')?.[1] || null;
+    const rttOpen = parseInt(event.tags.find((tag: NostrTag) => tag[0] === 'rtt-open')?.[1]) || null;
+    const rttWrite = parseInt(event.tags.find((tag: NostrTag) => tag[0] === 'rtt-write')?.[1]) || null;
+    const rtt = rttOpen || rttWrite || null;
+  
+    const operatorPubkey = event.tags.find((tag: NostrTag) => tag[0] === 'p')?.[1] || null;
+  
+    const supportedNips = event.tags
+      .filter((tag: NostrTag) => tag[0] === 'N')
+      .map((tag: NostrTag) => parseInt(tag[1])) || null;
+  
+    const software = event.tags.find((tag: NostrTag) => tag[0] === 's')?.[1] || null;
+    const version = event.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'nip11.version')?.[1] || null;
+  
+    const paymentRequired = event.tags.some((tag: NostrTag) => tag[0] === 'R' && tag[1] === 'payment') ? true : false;
+    const authRequired = event.tags.some((tag: NostrTag) => tag[0] === 'R' && tag[1] === 'auth') ? true : false;
+    const powRequired = event.tags.some((tag: NostrTag) => tag[0] === 'R' && tag[1] === 'auth') ? true : false;
+  
+    const geohash = event.tags.filter((tag: NostrTag) => tag[0] === 'g').map((tag: NostrTag) => tag[1]) || null;
+    const geocode = event.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'countryCode' && tag[1].length === 2)?.[1] || null;
+  
+    const isp = event.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2].includes('isp'))?.[1] || null;
+    const as = event.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'host.as')?.[1] || null;
+    const asname = event.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'host.asn')?.[1] || null;
+  
+    const ipv4 = event.tags.filter((tag: NostrTag) => tag[0] === 'l' && tag[2].includes('ipv4')).map((tag: NostrTag) => tag[1]) || null;
+  
+    return {
+      nid,
+      relay,
+      monitorPubkey,
+      created_at,
+      networks,
+      rtt,
+      operatorPubkey,
+      supportedNips,
+      software,
+      version,
+      paymentRequired,
+      authRequired,
+      geohash,
+      geocode,
+      isp,
+      as,
+      asname,
+      ipv4,
+      ipv6: null,
+      sslValidTo: null,
+      sslIssuer: null,
+    };
+  }