@nostrwatch/route66 0.0.1

package/src/models/Monitor.ts

@@ -0,0 +1,384 @@
+import { Nip66CheckEvent, type IEvent } from '@base/models';
+import { StateManager } from '@base/managers/StateManager';
+import { SyncRange, SyncRangeParameter, SyncStateManager } from '@base/managers/SyncStateManager';
+import { Filter } from 'nostr-tools';
+import { MonitorRegistration } from './MonitorRegistration';
+import { MonitorCached } from '@base/managers/MonitorManager';
+import { PubkeyProfile } from './PubkeyProfile';
+import { PubkeyRelays } from './PubkeyRelays';
+import { PFP } from '@base/utils/pfp';
+
+export enum RelayLiveness {
+  Online = 'ONLINE',
+  Offline = 'OFFLINE',
+  Dead = 'DEAD',
+}
+
+export type IRelaysByLiveness = {
+  online: IEvent[],
+  offline: IEvent[],
+  dead: IEvent[],
+}
+
+export type IMonitor = {
+  pubkey: string; 
+  eventId: string; 
+  lastActive: number;
+  frequency?: number;
+  geohash?: string;
+  geocode?: string[];
+  checks?: string[];
+}
+
+const defaultMonitor: IMonitor = {
+  pubkey: '',
+  eventId: '',
+  lastActive: -1,
+}
+
+export class Monitor {
+  enabled: boolean = false;   
+  priority: number = -1;
+  _registration?: MonitorRegistration;
+  _profile?: PubkeyProfile
+  _relays?: PubkeyRelays;
+  state?: SyncStateManager;
+  reportedOnline: number = 0;
+  deadThreshold: number = 60*60*24*30;  
+  _pfp?: string;
+  
+  private _lastActive: number = -1;
+  private _frequencyMutiplier: number = 1.5;
+  private _minFrequencySeconds: number = 60 * 60; // 1h
+  private _maxFrequencySeconds: number = 60 * 60 * 24; // 1d
+
+  constructor(event: IEvent) {
+    if(event.kind !== 10166) throw new Error('Monitor must be created from a 10166 event');
+    this.addRegistration(event);
+    this.state = new SyncStateManager(this.pubkey)
+  }
+
+  static fromCache(cached: MonitorCached): Monitor | undefined {
+    if(!cached?.registration) {
+      console.warn('Monitor.fromCache() called without valid registration event');
+      return 
+    }
+    const monitor = new Monitor(cached.registration);
+    if(cached?.profile){
+      monitor.addProfile(cached.profile);
+    }
+    if(cached?.relays){
+      monitor.addRelays(cached.relays)
+    }
+    monitor.enabled = cached.enabled ?? false;
+    monitor.priority = cached?.priority ?? 0;
+    monitor.lastActive = cached?.lastActive ?? -1;
+    return monitor;
+  }
+
+  toCache(): MonitorCached {
+    const cache: MonitorCached = {
+      pubkey: this.pubkey,
+      registration: this.registration?.json,
+      profile: this.profile?.json,
+      relays: this._relays?.json,
+      enabled: this.enabled,
+      priority: this.priority,
+      lastActive: this.lastActive
+    }
+    ////console.log('monitor cache', cache)
+    return cache
+  }
+
+  get events(): IEvent[] {
+    return [ this?.profile?.json ?? undefined, this.registration?.json ?? undefined, this._relays?.json ?? undefined ].filter(Boolean) as IEvent[]; 
+  }
+
+  get active(): boolean {
+    // console.log('Monitor: get active():', this.pubkey, this.lastActive)
+    if(this.lastActive < 0) return false;
+    return Math.round(Date.now()/1000)-this.frequency < this.lastActive;
+  }
+
+  get registration(): MonitorRegistration | undefined {
+    return this._registration;
+  }
+
+  private set registration(value: MonitorRegistration) {
+    this._registration = value;
+  }
+
+  get profile(): PubkeyProfile | undefined {
+    return this._profile;
+  }
+
+  private set profile(value: PubkeyProfile | undefined) {
+    this._profile = value;
+  }
+
+  get relays(): string[] {
+    return this._relays?.relays || [];
+  }
+
+  private set relays(event: IEvent) {
+    this._relays = new PubkeyRelays(event);
+  }
+
+  get name(): string {
+    return this.profile?.name || '';
+  }
+
+  get pfp(): string { 
+    if(!this._pfp) {
+      this._pfp = PFP.generate(this.pubkey)
+    }
+    return this._pfp as string;
+  }
+
+  get photo(): string | undefined {
+    return this.profile?.photo || this.pfp;
+  }
+
+  get image(): string | undefined  {
+    return this.photo;
+  }
+
+  get picture(): string | undefined  {
+    return this.photo;
+  }
+  
+  get banner(): string | undefined  {
+    return this.profile?.banner;
+  }
+
+  get checks(): string[] {
+    return this.registration?.checks || [];
+  }
+
+  set lastActive(value: number) {
+    if(!this.lastActive || value > this.lastActive) {
+      this._lastActive = value;
+      this.emitUpdate('lastActive', value); 
+    }
+  }
+
+  get lastActive(): number {
+    return this._lastActive;
+  }
+
+  // set lastSyncSince(rangeParameter: SyncRangeParameter) {
+  //   if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+  //   this.state.lastSyncSince = rangeParameter;
+  // }
+
+  // set lastSyncUntil(rangeParameter: SyncRangeParameter) {
+  //   if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+  //   this.state.lastSyncUntil = rangeParameter;
+  // }
+
+  get pubkey(): string {
+    return this.registration?.pubkey as string;
+  }
+
+  get networks(): string[] {
+    return this.registration?.networks || [];
+  } 
+
+  get eventId(): string {
+    return this.registration?.id as string;
+  }
+
+  get frequencyMultiplier(): number {
+    return this._frequencyMutiplier;
+  }
+
+  private set frequencyMultiplier(value: number) {
+    this.emitUpdate();
+    this._frequencyMutiplier = value;
+  }
+
+  get frequency(): number {
+    const f = this.registration?.frequency;
+    const base = f && f > 0 ? f : 60 * 60 * 12;
+    const scaled = base * this.frequencyMultiplier;
+    const clamped = Math.min(this._maxFrequencySeconds, Math.max(this._minFrequencySeconds, scaled));
+    return Math.round(clamped);
+  }
+
+  get geocode(): string | null {
+    return this.registration?.geocode || null;
+  }
+
+  get checkFilter(): Filter {
+    const kinds = [30166];
+    const now = Math.round(Date.now() / 1000);
+    const since = now - this?.frequency;
+    const until = now;
+    const authors = [this.pubkey];
+    return { kinds, since, until, authors };
+  }
+
+  //@deprecated
+  get checkFilterSync(): Filter {
+    const kind = 30166
+    const kinds = [kind];
+    const since = this.getLastSyncSince(kind) || Math.round(Date.now() / 1000) - this?.frequency;
+    const authors = [this.pubkey];
+    return { kinds, since, authors };
+  }
+
+  get checkFilterDead(): Filter {
+    // ////console.log(`Monitor:get checkFilter(): ${this?.pubkey}`, this?.frequency);
+    const kinds = [30166];
+    const since = 0;
+    const until = this.isDeadBefore;
+    const authors = [this.pubkey];
+    return { kinds, since, until, authors };
+  }
+
+  get checkFilterOffline(): Filter {
+    // ////console.log(`Monitor:get checkFilter(): ${this?.pubkey}`, this?.frequency);
+    const kinds = [30166];
+    const since = this.isOfflineBetween[0];
+    const until = this.isOfflineBetween[1];
+    const authors = [this.pubkey];
+    return { kinds, since, until, authors };
+  }
+
+  get checkFilterNotOnline(): Filter {
+    const kinds = [30166];
+    const since = 0;
+    const until = this.isOnlineAfter-1;
+    const authors = [this.pubkey];
+    return { kinds, since, until, authors };
+  }
+
+  get isDeadBefore(): number {
+    return Math.round(Date.now() / 1000) - this.deadThreshold;
+  }
+
+  get isOnlineAfter(): number {
+    return Math.round(Date.now() / 1000) - this.frequency;
+  }
+
+  get isOfflineBetween(): [number, number] {
+    return [this.isDeadBefore, this.isOnlineAfter];
+  }
+
+  enable(): void {
+    this.enabled = true;
+    this.emitUpdate();
+  }
+
+  disable(): void {
+    this.enabled = false;
+    this.emitUpdate();
+  }
+
+  relayIs(event: IEvent): RelayLiveness {
+    if(this.relayIsOnline(event)) return RelayLiveness.Online;
+    if(this.relayIsDead(event)) return RelayLiveness.Dead;
+    return RelayLiveness.Offline;
+  }
+
+  relayIsOffline(event: IEvent, strict: boolean = false): boolean {
+    const timestamp = (event.created_at as number);
+    return timestamp < this.isOnlineAfter && (!strict || timestamp >= this.isDeadBefore);
+  }
+
+  relayIsOnline(event: IEvent): boolean {
+    const timestamp = (event.created_at as number);
+    return timestamp >= this.isOnlineAfter;
+  }
+
+  relayIsDead(event: IEvent): boolean {
+    const timestamp = (event.created_at as number);
+    return timestamp < this.isDeadBefore;
+  }
+
+  async returnOnlineRelays(events: IEvent[]): Promise<IEvent[]> {
+    return events.filter(this.relayIsOnline.bind(this));
+  }
+
+  async returnOfflineRelays(events: IEvent[]): Promise<IEvent[]> {
+    return events.filter((events) => this.relayIsOffline(events));
+  }
+
+  async returnDeadRelays(events: IEvent[]): Promise<IEvent[]> {
+    return events.filter(this.relayIsDead.bind(this));
+  }
+  
+  async relaysByLiveness(events: IEvent[]): Promise<IRelaysByLiveness> {
+    const results: IRelaysByLiveness = {
+      online: [],
+      offline: [],
+      dead: [],
+    };
+    if(!this?.frequency) {
+      results.online = events;
+      return results;
+    }
+    events.forEach((event) => {
+      if(this.relayIsOnline(event)) {
+        results.online.push(event);
+      } else if(this.relayIsOffline(event)) {
+        results.offline.push(event);
+      } else if(this.relayIsDead(event)) {
+        results.dead.push(event);
+      }
+    });
+    return results;
+  }
+
+  maybeUpdateLastActive(event: IEvent | Nip66CheckEvent): boolean {
+    if(event.kind !== 30166) return false;
+    if(!event?.created_at) return false;
+    if(event.created_at > this.lastActive) {
+      this.lastActive = event.created_at;
+      return true;
+    }
+    return false;
+  }
+
+  getLastSyncSince(kind: number): number | undefined {
+    if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+    return this.state.getLastSyncSince(kind);
+  }
+
+  getLastSyncUntil(kind: number): number | undefined {
+    if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+    return this.state.getLastSyncUntil(kind);
+  }
+
+  getLastSync(kind: number): SyncRange | undefined {
+    if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+    return this.state.getLastSync(kind);  
+  }
+
+  setLastSync(kind: number, rangeKey: 'since' | 'until', value: number): void {
+    if(!this?.state) this.state = new SyncStateManager(this.pubkey)
+    this.state.setLastSync(kind, rangeKey, value);
+  }
+
+  addRegistration(event: IEvent): void {
+    this._registration = new MonitorRegistration(event);
+    this.emitUpdate('registration', this.registration)
+  }
+
+  addProfile(event: IEvent): void {
+    this._profile = new PubkeyProfile(event);
+    this.emitUpdate('profile', this.profile);
+  }
+
+  addRelays(event: IEvent): void {
+    this._relays = new PubkeyRelays(event);
+    this.emitUpdate('relays', this.relays);
+  }
+
+  private emitUpdate(key?: string, value?: any): void {
+    if(key && value) {
+      StateManager.emit(`monitor:update:${key}`, {pubkey: this.pubkey, value});
+    }
+    StateManager.emit('monitor:update', this);
+  }
+}

package/src/models/MonitorRegistration.ts

@@ -0,0 +1,25 @@
+import { Geocoded } from "./Geocoded";
+
+export class MonitorRegistration extends Geocoded {
+    
+    keys(keys: string[]): string[] {
+        return [
+            'pubkey',
+            'checks',
+            'frequency',
+        ];
+    }
+
+    get networks(): string[] {
+        return this.tags.filter(tag => tag[0] === 'n').map(tag => tag[1]);
+    }
+
+    get frequency(): number {   
+        return parseInt(this.tags.find(tag => tag[0] === 'frequency')?.[1] || "0")
+    }
+
+    get checks(): string[] {
+        return this.tags.filter(tag => tag[0] === 'c').map(tag => tag[1]);
+    }
+
+}

package/src/models/Nip11.ts

@@ -0,0 +1,275 @@
+import { deterministicHash } from "@base/utils";
+import { nip11 } from "nostr-tools";
+
+export type Nip11PaymentsUrl = `https://${string}` | `http://${string}`
+export type Nip11Fee = { amount: number; unit: string; period: number }
+export type Nip11Fees = {
+  admission?: Nip11Fee[];
+  publication?: Nip11Fee[];
+  subscription?: Nip11Fee[];
+}
+
+export interface RetentionDetails {
+  kinds: (number | number[])[]
+  time?: number | null
+  count?: number | null
+}
+
+export interface Limitations extends nip11.Limitations {}
+
+export interface RelayInformation extends nip11.RelayInformation {
+  limitation: Limitations;
+  banner: string;
+}
+
+export type INip11 = {
+  relay: string;
+  monitorPubkey: string;
+  hash: string | null;
+  nid?: string | null;
+  created_at: number;
+  json: Record<string, any> | null;
+}
+
+export class Nip11 {
+  private _json: RelayInformation;
+  private _hash: string;
+
+  constructor(nip11: RelayInformation) {
+    if(typeof nip11 === 'string'){
+      nip11 = JSON.parse(nip11);
+    }
+    this._json = nip11;
+    this._hash = deterministicHash(this._json)
+  }
+
+  /**
+   * Returns the name of the relay.
+   */
+  get name(): string | undefined {
+    return this.json.name;
+  }
+
+  get pubkey(): string | undefined {
+    return this.json?.pubkey;
+  }
+
+
+
+  /**
+   * Returns the description of the relay.
+   */
+  get description(): string | undefined {
+    return this.json.description;
+  }
+
+  /**
+   * Returns the icon of the relay.
+   */
+  get icon(): string | undefined {
+    return this.json.icon;
+  }
+
+  /**
+   * Returns the banner of the relay.
+   */
+  get banner(): string | undefined {
+    return this.json.banner;
+  }
+
+
+  /**
+   * Returns the contact information of the relay.
+   */
+  get contact(): string | undefined {
+    return this.json.contact;
+  }
+
+  /**
+   * Returns the software used by the relay.
+   */
+  get software(): string | undefined {
+    return this.json.software;
+  }
+
+  /**
+   * Returns the version of the relay software.
+   */
+  get version(): string | undefined {
+    return this.json.version;
+  }
+
+  /**
+   * Returns the limitation object for the relay.
+   */
+  get limitation(): Limitations {
+    return this.json.limitation;
+  }
+
+  /**
+   * Indicates whether the relay is restricted to read-only.
+   * If true, the relay will not accept writes.
+   * If false, the relay will accept writes.
+   * If undefined, the relay may accept writes.
+  */
+  get restrictedWrites(): boolean {
+    return typeof this.json?.limitation?.restricted_writes === 'boolean' 
+      ? this.json.limitation?.restricted_writes 
+      : false;
+  }
+
+  /**
+   * Indicates whether payment is required to use the relay.
+   */
+  get paymentRequired(): boolean {
+    return typeof this.json?.limitation?.payment_required === 'boolean' 
+      ? this.json.limitation?.payment_required 
+      : false;
+  }
+
+  /**
+   * Indicates whether authentication is required to use the relay.
+   */
+  get authRequired(): boolean {
+    return typeof this.json?.limitation?.auth_required === 'boolean' 
+      ? this.json.limitation?.auth_required 
+      : false;
+  }
+
+  /**
+   * Indicates whether proof-of-work is required to publish to relay.
+   */
+  get powRequired(): boolean {
+    return typeof this.minPowDifficulty === 'number' && this.minPowDifficulty > 0;
+  }
+
+  /**
+   * Returns required pow difficulty for the relay.
+   */
+  get minPowDifficulty(): number | undefined {
+    return typeof this.json?.limitation?.min_pow_difficulty === 'number'
+      ? this.json.limitation?.min_pow_difficulty 
+      : undefined;
+  }
+
+  /**
+   * Returns the hash associated with the relay.
+   */
+  get hash(): string | undefined {
+    return this._hash ?? undefined;
+  }
+
+  /**
+   * Returns the supported NIPs (Nostr Implementation Possibilities) by the relay.
+   */
+  get supportedNips(): number[] | undefined {
+    if(!Array.isArray(this.json?.supported_nips)){
+      if(typeof this.json?.supported_nips === 'number'){
+        return [this.json?.supported_nips]
+      }
+      else {
+        return;
+      }
+    }
+    return this.json?.supported_nips;
+  }
+
+  /**
+   * Returns the payments URL for the relay.
+   */
+  get paymentsUrl(): Nip11PaymentsUrl | undefined {
+    return this.json?.payments_url as Nip11PaymentsUrl || undefined;
+  }
+
+  /**
+   * Returns the fees object for the relay.
+   */
+  get fees():  any | undefined {
+    return this.json.fees
+  }
+
+  /**
+   * Returns the max message length if set
+   */
+  get maxMessageLength(): number | undefined {
+    return this.limitation?.max_message_length;
+  }
+
+  /**
+   * Returns the max message tags if set
+   */
+  get maxMessageTags(): number | undefined {
+    return this.limitation?.max_event_tags; 
+  }
+
+  /**
+   * Returns the max subscriptions tags if set
+   */
+  get maxSubscriptions(): number | undefined {
+    return this.limitation?.max_subscriptions;
+  }
+
+  /**
+   * Returns the max filters if set
+   */
+  get maxFilters(): number | undefined {
+    return this.limitation?.max_filters;
+  }
+
+  /**
+   * Returns the max limit if set
+   */
+  get maxLimit(): number | undefined {
+    return this.limitation?.max_limit;
+  }
+
+  /**
+   * Returns the max subid length if set
+   */
+  get maxSubidLength(): number | undefined {
+    return this.limitation?.max_subid_length;
+  }
+
+  /**
+   * Returns the max event tags if set
+   */
+  get maxEventTags(): number | undefined {
+    return this.limitation?.max_event_tags;
+  }
+
+  /**
+   * Returns the max content length if set
+   */
+  get maxContentLength(): number | undefined {
+    return this.limitation?.max_content_length;
+  }
+
+  /**
+   * Returns the lower limit of notes accepted by the relay.
+   */
+  get createdAtLowerLimit(): number | undefined {
+    return this.limitation?.created_at_lower_limit;
+  }
+
+  /**
+   * Returns the upper limit of notes accepted by the relay.
+   */
+  get createdAtUpperLimit(): number | undefined {
+    return this.limitation?.created_at_upper_limit;
+  }
+
+  get retention(): RetentionDetails[] | undefined {
+    return this.json?.retention as RetentionDetails[];
+  }
+
+  get hasRetention(): boolean {
+    return this.retention? true: false;
+  }
+
+  /**
+   * Returns the entire JSON payload.
+   */
+  get json(): RelayInformation {
+    return this._json;
+  }
+}