@nostrwatch/route66 0.0.1

package/src/interfaces/ICacheAdapterSharedWorkerCommand.ts

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

package/src/interfaces/INostrEvent.ts

@@ -0,0 +1 @@
+export { IEvent } from '@models/Event';  

package/src/interfaces/ISharedWorkerGlobalScope.ts

@@ -0,0 +1,6 @@
+export interface ISharedWorkerGlobalScope {
+  onconnect: ((this: ISharedWorkerGlobalScope, ev: MessageEvent) => any) | null;
+  addEventListener(type: 'connect', listener: (this: ISharedWorkerGlobalScope, ev: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+  postMessage(message: any, transfer?: Transferable[]): void;
+  port: MessagePort;
+}

package/src/interfaces/IWorkerCommand.ts

@@ -0,0 +1,5 @@
+export interface IWorkerCommand {
+  type: string;
+  websocketPort?: MessagePort;
+  cachePort?: MessagePort;
+}

package/src/interfaces/IWorkerGlobalScope.ts

@@ -0,0 +1,6 @@
+export interface IWorkerGlobalScope {
+  onmessage: ((this: IWorkerGlobalScope, ev: MessageEvent) => any) | null;
+  onerror: ((this: IWorkerGlobalScope, ev: ErrorEvent) => any) | null;
+  addEventListener(type: 'connect', listener: (this: IWorkerGlobalScope, ev: MessageEvent) => any, options?: boolean | AddEventListenerOptions): void;
+  postMessage(message: any, transfer?: Transferable[]): void;
+}

package/src/interfaces/TISO13166.ts

@@ -0,0 +1,17 @@
+export const enum ISO3166Type {
+  CountryCode = 'countryCode',
+  RegionCode = 'regionCode',
+}
+
+export const enum ISO3166Format {
+  Alpha = 'alpha',
+  Numeric = 'numeric',
+}
+
+export type RawGeoCode = (string | number)
+export type RawGeoCodes = RawGeoCode[]
+export type GeoCodesObjectRaw = {
+  countryCode: RawGeoCodes;
+  regionCode:  RawGeoCodes;
+}
+

package/src/interfaces/index.ts

@@ -0,0 +1,7 @@
+export { type IWorkerCommand } from './IWorkerCommand';
+export { type IEvent } from './INostrEvent';
+export { type IWorkerGlobalScope } from './IWorkerGlobalScope';
+export { type ISharedWorkerGlobalScope } from './ISharedWorkerGlobalScope';
+export { type ICacheAdapterSharedWorkerCommand } from './ICacheAdapterSharedWorkerCommand';
+export { type IAdaptersArgument } from "./IAdaptersArgument";
+export * from './TISO13166';

package/src/managers/MonitorManager.ts

@@ -0,0 +1,232 @@
+
+import { IEvent } from '@base/interfaces';
+import { Monitor } from '../models/Monitor';
+import { Nip66CheckEvent, NostrEvent } from '@base/models';
+
+export type MonitorPriorities = MonitorPriority[];
+
+export type MonitorCached = {
+  pubkey: string,
+  registration?: IEvent,
+  profile?: IEvent,
+  relays?: IEvent,
+  priority: number,
+  enabled: boolean,
+  lastActive?: number
+}
+
+export enum MonitorPriority {
+  Follows = 'FOLLOWS',
+  Wot = 'WOT',
+  Checks = 'CHECKS',
+  LoadSpeed = 'LOADSPEED',
+  Geohash = 'GEOHASH',
+  Country = 'COUNTRY',
+  Network = 'NETWORK',
+}
+
+export const DEFAULT_ANON_MONITOR_PRIORITIES: MonitorPriorities = [
+  MonitorPriority.Network,
+  MonitorPriority.Checks,
+  MonitorPriority.Geohash,
+];
+
+export const DEFAULT_AUTHED_MONITOR_PRIORITIES: MonitorPriorities = [
+  MonitorPriority.Follows,
+  MonitorPriority.Wot,
+  MonitorPriority.Checks,
+];
+
+export class MonitorManager {
+  private static instance: MonitorManager;
+
+  private monitors: Map<string, Monitor> = new Map();
+
+  private constructor() {}
+
+  public static getInstance(): MonitorManager {
+    if (!MonitorManager.instance) {
+      MonitorManager.instance = new MonitorManager();
+    }
+    return MonitorManager.instance;
+  }
+
+  get monitorsMap(): Map<string, Monitor> {
+    return this.monitors;
+  }
+
+  get array(): Monitor[] {
+    return Array.from(this.monitors.values());
+  }
+
+  get activeMonitors(): Monitor[] {
+    return this.array.filter((monitor) => monitor.active);
+  }
+
+  get enabledMonitors(): Monitor[] {  
+    return this.sortedMonitors.filter((monitor) => monitor.enabled);
+  }
+
+  get enabledActiveMonitors(): Monitor[] {
+    return this.enabledMonitors.filter((monitor) => monitor.active);
+  }
+
+  get disabledMonitors(): Monitor[] {  
+    return this.sortedMonitors.filter((monitor) => !monitor.enabled);
+  }
+
+  get disabledActiveMonitors(): Monitor[] {  
+    return this.disabledMonitors.filter((monitor) => monitor.active);
+  }
+
+  get disabledInactiveMonitors(): Monitor[] {  
+    return this.disabledMonitors.filter((monitor) => !monitor.active);
+  }
+
+  get sortedMonitors(): Monitor[] {
+    return this.sortMonitors();
+  }
+
+  get qualified(): Monitor[] {
+    const qualified = this.array.filter((monitor) => {
+      if (!monitor?.lastActive) return false;
+      if (!monitor?.registration?.checks?.length) return false;
+      if (!monitor?.profile) return false;
+      if (!monitor?.relays) return false;
+      return monitor.lastActive > 0;
+    });
+    return qualified;
+  }
+
+  isRelayOnline(event: Nip66CheckEvent | IEvent): boolean {
+    return this.array.some((monitor) => monitor.relayIsOnline(event));
+  }
+
+  isRelayOffline(event: Nip66CheckEvent | IEvent): boolean {
+    return this.array.every((monitor) => monitor.relayIsOffline(event) || monitor.relayIsDead(event));
+  }
+
+  isRelayDead(event: Nip66CheckEvent | IEvent): boolean {
+    return this.array.every((monitor) => monitor.relayIsDead(event));
+  }
+
+  loadMonitors(monitors: MonitorCached[]) {
+    monitors.forEach((monitor) => {
+      if(monitor?.registration) {
+        this.monitors.set(monitor.pubkey, Monitor.fromCache(monitor) as Monitor);  
+      }
+    });
+  }
+
+  handleEvent(event: IEvent): void {
+    const acceptedKinds = [0, 10002, 10166];
+    const { kind, pubkey } = event;
+    if(!acceptedKinds.includes(kind)) return
+    let monitor = this.monitors.get(pubkey);
+    if (!monitor && kind === 10166) {
+      monitor = new Monitor(event);
+      this.monitors.set(pubkey, monitor);
+    } else if(!monitor) {
+      console.warn(`Monitor not found for pubkey: ${pubkey}`);
+      return;
+    }
+    if (kind === 10166) {
+      monitor.addRegistration(event);
+    } else if (kind === 0) {
+      monitor.addProfile(event);
+    } else if (kind === 10002) {
+      monitor.addRelays(event);
+    }
+    this.monitors.set(pubkey, monitor);
+  }
+
+  updateMonitor(monitor: Monitor): void {
+    this.monitors.set(monitor.pubkey, monitor);
+  }
+
+  maybeUpdateLastActive(event: IEvent | Nip66CheckEvent): boolean {
+    const monitor = this.monitors.get(event.pubkey);
+    if(!monitor) return false;
+    return monitor.maybeUpdateLastActive(event);
+  }
+
+  sortMonitors(priority: MonitorPriority = MonitorPriority.Checks, apply: boolean = false): Monitor[] {
+    let sortedMonitors: Monitor[] = [];
+    switch (priority) {
+      case MonitorPriority.LoadSpeed:
+        return this.sort('ASC');
+      case MonitorPriority.Checks:
+      default:
+        return this.sort();
+    }
+  }
+
+  sort(order: 'ASC' | 'DESC' = 'DESC'): Monitor[] {
+    // Clone the array to avoid mutating the original
+    const monitors = [...this.array];
+
+    // Calculate scores for each monitor
+    const scores: Record<string, number> = {};
+    monitors.forEach((monitor) => {
+      if (!monitor?.registration?.pubkey) return;
+
+      let score = 0;
+      if (monitor.registration) score++;
+      if (monitor.registration.checks?.length) score += new Set(monitor.registration.checks).size;
+      if (monitor.profile) score++;
+      if (monitor.relays) score++;
+      if (!monitor.active) score = 0; // Inactive monitors have a score of 0
+
+      ////console.log(`prioritizeMonitors: ${monitor.registration.pubkey} score: ${score}`);
+      scores[monitor.registration.pubkey] = score;
+    });
+
+    // Sort monitors based on the defined criteria
+    monitors.sort((a, b) => {
+      // 1. Active Status: Active monitors come before inactive
+      if (a.active && !b.active) return -1; // a before b
+      if (!a.active && b.active) return 1;  // b before a
+
+      // If both are active or both inactive, proceed to next criteria
+
+      // 2. Enabled Status: Enabled monitors come before disabled
+      if (a.enabled && !b.enabled) return -1;
+      if (!a.enabled && b.enabled) return 1;
+
+      // 3. Number of Checks: More checks come first
+      const checksA = a.registration?.checks?.length || 0;
+      const checksB = b.registration?.checks?.length || 0;
+      if (checksA !== checksB) return checksB - checksA; // Descending
+
+      // 4. Reported Online: More reported online comes first
+      const onlineA = a.reportedOnline || 0;
+      const onlineB = b.reportedOnline || 0;
+      if (onlineA !== onlineB) return onlineB - onlineA; // Descending
+
+      // 5. Last Active: More recent comes first
+      const lastActiveA = a.lastActive || 0;
+      const lastActiveB = b.lastActive || 0;
+      if (lastActiveA !== lastActiveB) return lastActiveB - lastActiveA; // Descending
+
+      // 6. Score: Higher scores come first (or based on 'order')
+      const scoreA = scores[a.registration?.pubkey || ''] || 0;
+      const scoreB = scores[b.registration?.pubkey || ''] || 0;
+      if (order === 'ASC') return scoreA - scoreB;
+      return scoreB - scoreA;
+    });
+
+    return monitors;
+  }
+  
+
+  // prioritizeMonitors(priority: MonitorPriority = MonitorPriority.Checks): void {
+  //   const monitors = this.sortMonitors(priority);
+  //   monitors.forEach((sortedMonitor, index) => {
+  //     sortedMonitor.priority = index + 1;
+  //   });
+  // }
+
+  // static sortMonitorsByPriority(monitors: Monitor[]): Monitor[] {
+  //   return monitors.filter(monitor => monitor.priority >= 0).sort((a, b) => a.priority - b.priority);
+  // }
+}

package/src/managers/StageManager.ts

@@ -0,0 +1,83 @@
+import { StateManager } from "./StateManager";
+
+export enum StageSubject {
+    Monitors = 'MONITORS',
+    Monitor = 'MONITOR',
+    Relays = 'RELAYS',
+    Relay = 'RELAY',
+    User = 'USER',
+    AuthedUser = 'AUTHED_USER'
+}
+
+export enum Stage {
+    Bootstrap = 0,
+    Resync = 1,
+    Idle = 2
+}
+
+export enum StageStatus {
+    Begin = 0,
+    Processing = 1,
+    End = 2
+}
+
+
+export class LoadStage {
+    private _subject: StageSubject;
+    private _status: StageStatus;
+    private _stage: Stage;
+    
+    constructor(subject: StageSubject, stage: Stage, status: StageStatus) {
+        this._subject = subject;
+        this._stage = stage;
+        this._status = status;
+    }
+
+    get subject(): StageSubject {
+        return this._subject;
+    }
+
+    get stage(): Stage {
+        return this._stage;
+    }
+
+    get status(): StageStatus {
+        return this._status;
+    }
+
+    begin(){
+        this._status = StageStatus.Begin;
+        StateManager.emit('status', this);
+    }
+
+    process() {
+        this._status = StageStatus.Processing;
+        StateManager.emit('status', this);
+    }
+
+    end() {
+        this._status = StageStatus.End;
+        StateManager.emit('status', this);
+    }
+}
+
+
+export class LoadStageManager {
+    private subjects: Record<StageSubject, LoadStage | null> = {
+        [StageSubject.Monitors]: null,
+        [StageSubject.Monitor]: null,
+        [StageSubject.Relays]: null,
+        [StageSubject.Relay]: null,
+        [StageSubject.User]: null,
+        [StageSubject.AuthedUser]: null
+    };
+    
+    begin(stage: LoadStage) {
+        stage.begin();
+        this.subjects[stage.subject] = stage;  
+    }
+
+    finish(stage: LoadStage) {
+
+    }
+}

package/src/managers/StateManager.ts

@@ -0,0 +1,176 @@
+import { LocalStorageWrapper } from "@base/core/LocalStorageWrapper";
+import { EventEmitter } from "tseep";
+
+export type StateAbort = {
+    controller: AbortController;
+    signal: AbortSignal;
+};
+
+export type StateStats = Map<string, number>;
+
+export type UserPreferences = Map<string, any>
+
+export type UserState = {
+    pubkey?: string,
+    authed?: boolean,
+    profile?: any,
+    relays?: string[]
+    preferences?: UserPreferences
+}
+
+export class StateManager {
+    private static _abortController: AbortController = new AbortController();
+    private static _emitter: EventEmitter = new EventEmitter();
+    private static _localStorage: LocalStorageWrapper = new LocalStorageWrapper("state")
+    private static _enableStats: boolean = true;
+    private static _stats: StateStats = new Map();
+    private static _user: UserState = {}; 
+
+    // Getter for the AbortController
+    static get abortController(): AbortController {
+        return this._abortController;
+    }
+
+    // Getter for the AbortSignal
+    static get abortSignal(): AbortSignal {
+        return this._abortController.signal;
+    }
+
+    // Abort action that emits an "abort" event
+    static abort(): void {
+        this.incrementStat('ac:abort');
+        if (!this.abortSignal.aborted) {
+            this._abortController.abort();
+            this._emitter.emit("abort");
+        }
+    }
+
+    // Check if aborted
+    static aborted(): boolean {
+        return this.abortSignal.aborted;
+    }
+
+    // Reset the AbortController and emit a "reset-abort" event
+    static resetAbort(): void {
+        this.incrementStat('ac:reset-abort');
+        this._abortController = new AbortController();
+        this._emitter.emit("reset-abort");
+    }
+
+    // Getter for LocalStorageWrapper
+    static get localStorage(): LocalStorageWrapper {
+        return this._localStorage;
+    }
+
+    // LocalStorageWrapper methods
+    static set(key: string, value: any): void {
+        this.incrementStat('ls:set');
+        this.localStorage.setItem(key, value);
+    }
+
+    static get(key: string): any {
+        this.incrementStat('ls:get');
+        return this.localStorage.getItem(key);
+    }
+
+    static remove(key: string): void {
+        this.incrementStat('ls:remove');
+        this.localStorage.removeItem(key);
+    }
+
+    static clear(): void {
+        this.incrementStat('ls:clear');
+        this.localStorage.clear();
+    }
+
+    static size(): number {
+        this.incrementStat('ls:size');
+        return this.localStorage.length();
+    }
+
+    static key(index: number): string | null {
+        this.incrementStat('ls:key');
+        return this.localStorage.key(index);
+    }
+
+    // Getter for EventEmitter
+    static get emitter(): EventEmitter {
+        return this._emitter;
+    }
+
+    // Emit an event
+    static emit(event: string, ...args: any[]): void {
+        // ////console.log(`emitting event: ${event}`);
+        this.incrementStat('emitter:emit');
+        this._emitter.emit(event, ...args);
+    }
+
+    // Add a listener for an event
+    static on(event: string, listener: (...args: any[]) => void): void {
+        this.incrementStat('emitter:on');
+        this._emitter.on(event, listener);
+    }
+
+    // Add a one-time listener for an event
+    static once(event: string, listener: (...args: any[]) => void): void {
+        this.incrementStat('emitter:once');
+        this._emitter.once(event, listener);
+    }
+
+    // Remove a listener for an event
+    static off(event: string, listener?: (...args: any[]) => void): void {
+        this.incrementStat('emitter:off');
+        if (listener) {
+            this._emitter.off(event, listener);
+        } else {
+            this._emitter.removeAllListeners(event);
+        }
+    }
+
+    // Clear all listeners for a specific event
+    static clearListeners(event: string): void {
+        this.incrementStat('emitter:clear');
+        this._emitter.removeAllListeners(event);
+    }
+
+    //internal
+    static get stats(): Map<string, number> {
+        return this._stats;
+    }
+
+    static enableStats(): void {
+        this._enableStats = true;
+    }
+
+    static disableStats(): void {
+        this._enableStats = false;
+    }
+
+    static incrementStat(key: string): void {
+        if(this._enableStats) {
+            const value = this.getStat(key);
+            this.setStat(key, value + 1);
+        }
+    }
+
+    static decrementStat(key: string): void {
+        if(this._enableStats) {
+            const value = this.getStat(key);
+            this.setStat(key, value - 1);
+        }
+    }
+
+    static clearStats(): void {
+        this._stats.clear();
+    }
+
+    static setStat(key: string, value: number) {
+        if(this._enableStats) 
+            this._stats.set(key, value);
+    }
+
+    static getStat(key: string): number {
+        if(!this._enableStats) return 0
+        return this._stats.get(key) || 0;
+    }
+}

package/src/managers/SyncStateManager.ts

@@ -0,0 +1,60 @@
+import { LocalStorageWrapper } from "@base/core/LocalStorageWrapper";
+import { SyncKeys } from "@base/utils/SyncKeys";
+
+export type SyncRange = { since?: number, until?: number } 
+
+export type SyncRangeParameter = {
+    kind: number,
+    value: number
+}
+
+export class SyncStateManager {
+    private keyHelper: SyncKeys;
+    private localStorage: LocalStorageWrapper = new LocalStorageWrapper('monitor');
+  
+    constructor(private pubkey: string) {
+      this.keyHelper = new SyncKeys(pubkey);
+    }
+
+    set lastSyncSince(rangeParameter: SyncRangeParameter) {
+      this.setLastSync(rangeParameter.kind, 'since', rangeParameter.value);
+    }
+  
+    set lastSyncUntil(rangeParameter: SyncRangeParameter) {
+      this.setLastSync(rangeParameter.kind, 'until', rangeParameter.value);
+    }
+
+    setLastSync(kind: number, rangeKey: 'since' | 'until', value: number): void {
+        const key = this.keyHelper.generateKey('lastSync', kind, rangeKey);
+        this.localStorage.setItem(key, value.toString());
+    }
+
+    getLastSync(kind: number): SyncRange | undefined {
+      const since = this.getLastSyncSince(kind);
+      const until = this.getLastSyncUntil(kind);
+      if(since || until){
+        return {
+          since,
+          until
+        };
+      }
+      return undefined;
+    }
+  
+    getLastSyncSince(kind: number): number | undefined {
+      return this.getLastSyncValue(kind, 'since');
+    }
+  
+    getLastSyncUntil(kind: number): number | undefined {
+      return this.getLastSyncValue(kind, 'until');
+    }
+  
+    getLastSyncValue(kind: number, rangeKey: 'since' | 'until'): number | undefined {
+        const key = this.keyHelper.generateKey('lastSync', kind, rangeKey);
+        const returnedValue = this.localStorage.getItem(key);
+        if(!returnedValue) return undefined;
+        const value = parseInt(returnedValue);
+        ////console.log(`getLastSyncValue: ${key} -> ${returnedValue} === ${value}`);
+        return value;
+    }
+  }

package/src/models/Check.ts

@@ -0,0 +1,34 @@
+export interface ICheckBase {
+  nid: string;
+  relay: string;
+  monitorPubkey: string;
+}
+
+export interface ICheckMeta {
+  created_at: number;
+
+  network?: string | null;
+  rtt?: number | null;
+
+  operatorPubkey?: string | null;
+  supportedNips?: number[] | null;
+  software?: string | null;
+  version?: string | null;
+  paymentRequired?: number | null;
+  authRequired?: number | null;
+
+  geohash?: string[] | null;
+  geocode?: string[] | null;
+
+  isp?: string | null;
+  as?: string | null;
+  asname?: string | null;
+
+  ipv4?: string[] | null;
+  ipv6?: string[] | null;
+
+  sslValidTo?: number | null;
+  sslIssuer?: string | null;
+}
+
+export interface ICheck extends ICheckBase, ICheckMeta {}