@nostrwatch/route66 0.0.1

package/src/models/Nip66CheckEvent.ts

@@ -0,0 +1,316 @@
+import { transformCheck } from "@base/transform/TransformCheck";
+import { IEvent, NostrEvent, NostrTag } from "./Event";
+import { Geocoded } from "./Geocoded";
+import { nip19 } from "nostr-tools";
+import { Nip11, Nip11Fee, Nip11Fees, RetentionDetails, type RelayInformation  } from "./Nip11";
+import { isPubkey } from "@base/utils/nostr";
+import { Retention } from "nostr-tools/nip11";
+
+export class Nip66CheckEvent extends Geocoded implements IEvent {
+    _nip11?: Nip11 | false;
+
+    static keys = [
+      'id', 
+      'relay', 
+      'monitorPubkey', 
+      'created_at', 
+      'networks', 
+      'rtt', 
+      'operatorPubkey', 
+      'operatorPubkeyValid',
+      'name',
+      'description',
+      'supportedNips', 
+      'software', 
+      'icon',
+      'hasIcon',
+      'banner',
+      'hasBanner',
+      'version', 
+      'hasNip11',
+      'nip11Hash',
+      'hasRetention',
+      'retentionPolicy',
+      'hasLimitations',
+      'paymentRequired', 
+      'authRequired', 
+      'powRequired',
+      'minPowDifficulty',
+      'restrictedWrites',
+      'maxSubscriptions',
+      'maxFilters',
+      'maxLimit',
+      'maxSubidLength',
+      'maxEventTags',
+      'maxContentLength',
+      'createdAtLowerLimit',
+      'createdAtUpperLimit',
+      'dd',
+      'geohash', 
+      'geocode', 
+      'isp', 
+      'as', 
+      'asname', 
+      'ipv4', 
+      'ipv6', 
+      'sslValidTo', 
+      'sslIssuer',
+      'fees',
+      'subscriptionFee',
+      'publicationFee',
+      'admissionFee'
+    ];
+
+    constructor(event: IEvent) {
+      super(event);
+      this.nip11 = this.content;
+    }
+
+    get nip11(): Nip11 | undefined  {
+      if(this._nip11 === false) return undefined;
+      if(this._nip11 instanceof Nip11) return this._nip11; 
+      return undefined;
+    }
+
+    set nip11(nip11: string | RelayInformation) {
+      if(typeof nip11 === 'string' && nip11.length > 2) {
+        try { 
+          const n11: RelayInformation = JSON.parse(nip11);
+          if(Object.keys(nip11).length > 0) {
+            this._nip11 = new Nip11(n11);
+          }
+          else {
+            this._nip11 = false;
+          }
+        }
+        catch(e){
+          this._nip11 = false;
+        }
+      }
+      else if(typeof nip11 === 'object' && Object.keys(nip11).length > 0) {
+        this._nip11 = new Nip11(nip11 as RelayInformation);
+      }
+    }
+
+    get hasNip11(): boolean {
+      return this._nip11 instanceof Nip11 && Object.keys(this._nip11)?.length > 0;
+    }
+
+    get nip11Hash(): string | undefined {
+      if(this.hasNip11){
+        return (this._nip11 as Nip11)?.hash
+      }
+      return undefined;
+    }
+
+    get operatorPubkey(): string | null {
+      const fromNip11 = this.nip11?.pubkey;
+      return fromNip11? 
+        fromNip11: 
+        this.tags.find((tag: NostrTag) => tag[0] === 'p')?.[1] || null;
+    }
+
+    get operatorPubkeyValid(): boolean | undefined {
+      if(!this.operatorPubkey) return undefined;
+      return isPubkey(this.operatorPubkey);
+    }
+  
+    get relay(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'd')?.[1] || null;
+    }
+
+    get url(): string | null {
+      return this.relay;
+    }
+  
+    get monitorPubkey(): string {
+      return this.pubkey;
+    }
+  
+    get created_at(): number | null {
+      return this.json.created_at;
+    }
+  
+    get networks(): string[] | null {
+      return this.tags.filter((tag: NostrTag) => tag[0] === 'n').map((tag: NostrTag) => tag[1]) || null;
+    }
+  
+    get rtt(): number | null {
+      const rtt = this.tags.find((tag: NostrTag) => tag[0] === 'rtt-open')?.[1]
+      return rtt? parseInt(rtt): null;
+    }
+  
+    get supportedNips(): string[] | null {
+      if(!this.nip11) return null;
+      const nip11Nips = this.nip11?.supportedNips?.map( n => n.toString() ) || []
+      if(nip11Nips) {
+        return Array.from(new Set( this.nip11?.supportedNips?.map( n => n.toString() ) || [] ));
+      }
+      return this.tags.filter((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'nip11.supported_nips').map((tag: NostrTag) => tag[1]) || null;  
+    }
+
+    get name(): string | null {
+      return this.nip11?.name || null;
+    }
+  
+    get software(): string | null {
+      return this.nip11?.software?.toLowerCase() || null;
+    }
+  
+    get version(): string | null {
+      return this.nip11?.version || null;
+    }
+
+    get description(): string | null {  
+      return this.nip11?.description || null;
+    }
+
+    get contact(): string | null {
+      return this.nip11?.contact || null;
+    }
+
+    get hasLimitations(): boolean {
+      return this.nip11?.limitation? true: false;
+    }
+
+    get retentionPolicy(): RetentionDetails[] | null {
+      return this.nip11?.retention || null;
+    }
+
+    get hasRetentionPolicy(): boolean {
+      return this.nip11?.hasRetention || false;
+    }
+
+    get maxMessageLength(): number | null {
+      return this.nip11?.maxMessageLength || null;
+    }
+
+    get maxMessageTags(): number | null {
+      return this.nip11?.maxMessageTags || null;
+    }
+
+    get paymentsUrl(): string | null {
+      return this.nip11?.paymentsUrl || null;
+    }
+
+    get fees(): Nip11Fees | null {
+      return this.nip11?.fees || null;
+    }
+
+    get subscriptionFee(): Nip11Fee[] | null {
+      return this.fees?.subscription || null;
+    }
+
+    get publicationFee(): Nip11Fee[] | null {
+      return this.fees?.publication || null;
+    }
+
+    get admissionFee(): Nip11Fee[] | null {
+      return this.fees?.admission || null;
+    }
+  
+    get isp(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2].includes('isp'))?.[1] || null;
+    }
+  
+    get as(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'host.as')?.[1] || null;
+    }
+  
+    get asname(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'host.asn')?.[1] || null;
+    }
+  
+    get ipv4(): string[] | null {
+      return this.tags.filter((tag: NostrTag) => tag[0] === 'l' && tag[2].includes('ipv4')).map((tag: NostrTag) => tag[1]) || null;
+    }
+  
+    get ipv6(): string[] | null {
+      return this.tags.filter((tag: NostrTag) => tag[0] === 'l' && tag[2].includes('ipv6')).map((tag: NostrTag) => tag[1]) || null;
+    }
+  
+    get sslValidTo(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'ssl.validTo')?.[1] || null;
+    }
+  
+    get sslIssuer(): string | null {
+      return this.tags.find((tag: NostrTag) => tag[0] === 'l' && tag[2] === 'ssl.issuer')?.[1] || null;
+    }
+  
+    get check(): any {
+      return transformCheck(this.json);
+    }
+
+    get icon(): string | null {
+      return this.nip11?.icon || null;
+    }
+
+    get hasIcon(): boolean {
+      return !!this.icon;
+    }
+
+    get banner(): string | null {
+      return this.nip11?.banner || null;
+    }
+
+    get hasBanner(): boolean {
+      return !!this.banner;
+    }
+
+    //nip11 limitations 
+    get maxSubscriptions(): number | null {
+      return this.nip11?.maxSubscriptions || null;
+    }
+
+    get maxFilters(): number | null {
+      return this.nip11?.maxFilters || null;
+    }
+
+    get maxLimit(): number | null {
+      return this.nip11?.maxLimit || null;
+    }
+
+    get maxSubidLength(): number | null {
+      return this.nip11?.maxSubidLength || null;
+    }
+
+    get maxEventTags(): number | null {
+      return this.nip11?.maxEventTags || null;
+    }
+
+    get maxContentLength(): number | null {
+      return this.nip11?.maxContentLength || null;
+    }
+
+    get createdAtLowerLimit(): number | null {
+      return this.nip11?.createdAtLowerLimit || null;
+    }
+
+    get createdAtUpperLimit(): number | null {
+      return this.nip11?.createdAtUpperLimit || null;
+    }
+
+    get paymentRequired(): boolean {
+      return this.nip11?.paymentRequired || false;
+    }
+  
+    get authRequired(): boolean {
+      return this.nip11?.authRequired || false;
+    }
+  
+    get powRequired(): number | boolean {
+      return this.nip11?.powRequired || false;
+    }
+
+    get minPowDifficulty(): number | boolean {
+      return this.nip11?.minPowDifficulty || false;
+    }
+
+    get restrictedWrites(): boolean {
+      return this.nip11?.restrictedWrites || false;
+    }
+
+    get hostname(): string | null {
+      return this.url? new URL(this.url).hostname: null;
+    }
+  }

package/src/models/PubkeyProfile.ts

@@ -0,0 +1,67 @@
+import { nip19 } from "nostr-tools";
+import { IEvent, NostrEvent } from "./Event";
+import type { Nip05 } from "nostr-tools/nip05";
+
+export class PubkeyProfile extends NostrEvent {
+
+    private _parsed?: any;
+
+    constructor(event: IEvent) {
+        super(event)
+        try {
+            this.parsed = JSON.parse(this.content);
+        }
+        catch(e){
+            this.parsed = {}
+        }
+    }
+
+    get name(): string | undefined {
+        return this.parsed?.name
+    }
+
+    get photo(): string | undefined {
+        return this.parsed?.photo || this.parsed?.picture
+    }
+
+    get picture(): string | undefined {
+        return this.photo 
+    }
+
+    get about(): string | undefined {
+        return this.parsed?.about
+    }
+
+    get website(): string | undefined {
+        return this.parsed?.website
+    }
+
+    get banner(): string | undefined {
+        return this.parsed?.banner
+    }
+
+    get lud06(): string | undefined {
+        return this.parsed?.lud06
+    }
+
+    get lud16(): string | undefined {
+        return this.parsed?.lud16
+    }
+
+    get nip05(): Nip05 | undefined {
+        return this.parsed?.nip05
+    }
+
+    get parsed(): any {
+        return this._parsed;
+    }
+
+    set parsed(value: any) {
+        this._parsed = value;
+    }
+
+    get npub(): string | undefined {
+        return nip19.npubEncode(this.pubkey)
+    }
+
+}

package/src/models/PubkeyRelays.ts

@@ -0,0 +1,9 @@
+import { NostrEvent } from "./Event";
+
+export class PubkeyRelays extends NostrEvent {
+
+    get relays(): string[] {
+        return this.json.tags.filter(tag => tag[0] === 'r').map(tag => tag[1]);
+    }
+    
+}

package/src/models/Relay.ts

@@ -0,0 +1,8 @@
+export type IRelay = {
+  relay: string;
+  lastSeen: number;
+  network: string;
+  created_at: number;
+  ignore: boolean;
+  score?: number | null;
+}

package/src/models/RelayCheckAggregate.ts

@@ -0,0 +1,222 @@
+// Assume that you import your Nip66CheckEvent from its module.
+import { Nip66CheckEvent } from "./Nip66CheckEvent";
+
+/**
+ * A context used to normalize RTT values globally.
+ */
+export interface NormalizationContext {
+  globalMin: number;
+  range: number;
+}
+
+/**
+ * A RelayCheckAggregate retains a reference to a live array of Nip66CheckEvents
+ * (for a given relay) and computes merged values on demand.
+ *
+ * - For keys not explicitly handled, it returns the first non-null value
+ *   from the most recent event to the oldest.
+ * - For derivative keys (such as "rtt", "rttNormalized", "seenTimes", "seenBy",
+ *   and "lastSeen") it computes the value on the fly.
+ */
+export class RelayCheckAggregate {
+  /**
+   * (Optional) A normalization context provided by the aggregator.
+   * It is used to compute the normalized RTT value.
+   */
+  public normalizationContext?: NormalizationContext;
+
+  /**
+   * @param checks A live reference to an array of Nip66CheckEvents for a relay.
+   */
+  constructor(public readonly checks: Nip66CheckEvent[]) {}
+
+  /**
+   * Returns the merged value for a given key.
+   *
+   * The merging rules are:
+   * - **seenTimes**: returns the number of checks.
+   * - **rtt**: returns the average RTT (if any).
+   * - **rttNormalized**: returns the normalized RTT (using the normalizationContext, if set).
+   * - **seenBy**: returns an array of monitor public keys (collected from each event).
+   * - **lastSeen**: returns the latest created_at value.
+   * - For any other key: iterates (from the most recent to oldest) and returns the first non-null value.
+   *
+   * @param key The key for which to retrieve the merged value.
+   */
+  public getValue(key: string): any {
+    switch (key) {
+      case "seenTimes": {
+        // Return the count of events.
+        return this.checks.length;
+      }
+      case "rtt": {
+        // Compute the average rtt from all events that have a valid numeric rtt.
+        const rtts = this.checks
+          .map((check) => check.rtt)
+          .filter((r): r is number => typeof r === "number");
+        return rtts.length > 0 ? rtts.reduce((a, b) => a + b, 0) / rtts.length : null;
+      }
+      case "rttNormalized": {
+        const avg = this.getValue("rtt");
+        if (avg === null || !this.normalizationContext) return null;
+        const { globalMin, range } = this.normalizationContext;
+        return Math.round(((avg - globalMin) / range) * 10000) / 10000;
+      }
+      case "seenBy": {
+        // Collect the monitorPubkey from each check.
+        return this.checks.reduce<string[]>((acc, check) => {
+          if (check.monitorPubkey !== null && check.monitorPubkey !== undefined) {
+            acc.push(check.monitorPubkey);
+          }
+          return acc;
+        }, []);
+      }
+      case "lastSeen": {
+        // Return the highest (latest) created_at value.
+        let latest: number | null = null;
+        for (const check of this.checks) {
+          const created = check.created_at;
+          if (created !== null && created !== undefined && (latest === null || created > latest)) {
+            latest = created;
+          }
+        }
+        return latest;
+      }
+      default: {
+        // For any other key, return the first non-null value found in the events.
+        // The Nip66CheckEvent model already provides getters for its keys, so we assume
+        // that each check has up-to-date values.
+        for (let i = this.checks.length - 1; i >= 0; i--) {
+          const value = this.checks[i][key as keyof Nip66CheckEvent];
+          if (value !== null && value !== undefined) {
+            return value;
+          }
+        }
+        return null;
+      }
+    }
+  }
+
+  /**
+   * Returns an aggregate object containing merged values for a set of keys.
+   *
+   * The keys include those defined in the Nip66CheckEvent.keys static property
+   * (which come directly from your event model) plus some additional custom keys.
+   */
+  public get aggregate(): { [key: string]: any } {
+    // Combine the keys from your imported Nip66CheckEvent and our custom ones.
+    const keys = [
+      ...Nip66CheckEvent.keys,
+      "seenTimes",
+      "rtt",
+      "rttNormalized",
+      "seenBy",
+      "lastSeen",
+    ];
+    const result: { [key: string]: any } = {};
+    for (const key of keys) {
+      result[key] = this.getValue(key);
+    }
+    return result;
+  }
+}
+
+/**
+ * The RelayCheckAggregator groups an array of Nip66CheckEvents by relay.
+ *
+ * It creates a RelayCheckAggregate for each normalized relay URL (using the
+ * value provided by Nip66CheckEvent.relay) and computes a global normalization
+ * context for RTT values.
+ */
+export class RelayCheckAggregator {
+  private _aggregates: Record<string, RelayCheckAggregate> = {};
+
+  /**
+   * @param checks An array of Nip66CheckEvents.
+   */
+  constructor(checks: Nip66CheckEvent[]) {
+    this.groupChecks(checks);
+    this.updateNormalizationContext();
+  }
+
+  /**
+   * Groups an array of checks by normalized relay and adds them to the aggregates.
+   *
+   * @param checks An array of Nip66CheckEvents.
+   */
+  private groupChecks(checks: Nip66CheckEvent[]): void {
+    for (const check of checks) {
+      this.addCheck(check, /* updateNormalization */ false);
+    }
+  }
+
+  /**
+   * Adds a single Nip66CheckEvent to the aggregator.
+   *
+   * The check is filtered and normalized in the same way as in the constructor.
+   * After adding the check, the global normalization context is recomputed.
+   *
+   * @param check The Nip66CheckEvent to add.
+   * @param updateNormalization Whether to update the normalization context after adding this check.
+   *                             Defaults to true.
+   */
+  public addCheck(check: Nip66CheckEvent, updateNormalization: boolean = true): void {
+    // Skip checks without a relay.
+    const relayValue = check.relay;
+    if (!relayValue) return;
+
+    // Exclude events with a tag that starts with '30166:' on an 'a' tag.
+    if (check.tags.find((tag) => tag[0] === "a" && tag[1]?.startsWith("30166:"))) {
+      return;
+    }
+
+    let normalizedRelay: string;
+    try {
+      normalizedRelay = new URL(relayValue).toString();
+    } catch (e) {
+      console.warn("Could not normalize relay:", relayValue);
+      return;
+    }
+
+    // If the group exists, add to it; otherwise, create a new group.
+    if (!this._aggregates[normalizedRelay]) {
+      this._aggregates[normalizedRelay] = new RelayCheckAggregate([]);
+    }
+    this._aggregates[normalizedRelay].checks.push(check);
+
+    // Update the normalization context if needed.
+    if (updateNormalization) {
+      this.updateNormalizationContext();
+    }
+  }
+
+  /**
+   * Recomputes the global normalization context for RTT values and updates all aggregates.
+   */
+  private updateNormalizationContext(): void {
+    const avgRtts: number[] = [];
+    for (const relay in this._aggregates) {
+      const agg = this._aggregates[relay];
+      const avg = agg.getValue("rtt");
+      if (avg !== null) {
+        avgRtts.push(avg);
+      }
+    }
+    const globalMin = avgRtts.length > 0 ? Math.min(...avgRtts) : 0;
+    const globalMax = avgRtts.length > 0 ? Math.max(...avgRtts) : 0;
+    const range = globalMax - globalMin || 1;
+    const normalizationContext: NormalizationContext = { globalMin, range };
+
+    // Attach the normalization context to each aggregate.
+    for (const relay in this._aggregates) {
+      this._aggregates[relay].normalizationContext = normalizationContext;
+    }
+  }
+
+  /**
+   * Returns an object containing the RelayCheckAggregate instances keyed by normalized relay URL.
+   */
+  public getAggregates(): Record<string, RelayCheckAggregate> {
+    return this._aggregates;
+  }
+}

package/src/models/Ssl.ts

@@ -0,0 +1,8 @@
+export type ISsl = {
+  nid: string;
+  relay: string; 
+  created_at: number;
+  monitorPubkey: string;
+  hash: string;
+  cert: string;
+}

package/src/models/_.ts

@@ -0,0 +1,7 @@
+export const modelDefaults = <T>(): { [K in keyof T]: T[K] | null } => {
+  const defaultObject = {} as { [K in keyof T]: T[K] | null };
+  Object.keys(defaultObject).forEach(key => {
+    defaultObject[key as keyof T] = null as any;
+  });
+  return defaultObject;
+}

package/src/models/index.ts

@@ -0,0 +1,14 @@
+export * from './_'
+export { type IEvent, NostrEvent, SOURCE } from './Event';
+export { Nip66CheckEvent } from './Nip66CheckEvent';
+export { DeltaEvent, type OperationalStatus } from './DeltaEvent';
+export { RelayCheckAggregate, RelayCheckAggregator } from './RelayCheckAggregate';
+export { Geocoded } from './Geocoded';
+export { type IMonitor, Monitor } from './Monitor';
+export type { IRelay } from './Relay';
+export type { IGeohash } from './Geohash';
+export type { ICheck } from './Check';
+export type { IGeocode } from './Geocode';
+export  {  Nip11, type INip11, type RelayInformation } from './Nip11';
+export { PubkeyProfile } from './PubkeyProfile';
+export { PubkeyRelays } from './PubkeyRelays';

package/src/routines/PurgeInactiveMonitors.ts

@@ -0,0 +1,10 @@
+import { Routine } from "@base/core/Routine";
+
+export class PurgeInactiveMonitors extends Routine {
+    constructor() {
+        super();
+    }
+    async run() {
+        ////console.log('PurgeInactiveMonitors');
+    }
+}

package/src/routines/PurgeOldChecks.ts

@@ -0,0 +1,10 @@
+import { Routine } from "@base/core/Routine";
+
+export class PurgeOldChecks extends Routine {
+    constructor() {
+        super();
+    }
+    async run() {
+        ////console.log('PurgeOldChecks');
+    }
+}

package/src/services/AuditorService.ts

@@ -0,0 +1,3 @@
+import { Service } from "./Service";
+
+export class AuditorService extends Service {}