@nostrwatch/route66 0.0.1

package/src/models/DeltaEvent.ts

@@ -0,0 +1,152 @@
+/**
+ * DeltaEvent Model
+ *
+ * Wraps Kind 1066 delta events with convenient accessors for relay state changes.
+ * These events track relay status transitions, RTT measurements, and configuration changes.
+ */
+
+import { IEvent, NostrEvent, NostrTag } from './Event';
+
+/**
+ * Operational status values for relay liveness transitions
+ */
+export type OperationalStatus = 'init' | 'down' | 'up';
+
+/**
+ * DeltaEvent - Model for Kind 1066 delta events
+ *
+ * Kind 1066 events capture incremental changes to relay state over time.
+ * They are used to build time series data for RTT charts, uptime timelines, etc.
+ *
+ * @example
+ * ```typescript
+ * const deltaEvent = new DeltaEvent(eventJson);
+ * console.log(deltaEvent.relay);            // 'wss://relay.example.com'
+ * console.log(deltaEvent.operationalStatus); // 'up' | 'down' | 'init' | null
+ * console.log(deltaEvent.rtt);              // 150 (milliseconds)
+ * console.log(deltaEvent.online);           // true
+ * ```
+ */
+export class DeltaEvent extends NostrEvent implements IEvent {
+  static readonly KIND = 1066;
+
+  static keys = [
+    'id',
+    'relay',
+    'monitorPubkey',
+    'created_at',
+    'operationalStatus',
+    'rtt',
+    'retryCount',
+    'periods',
+    'online',
+  ];
+
+  constructor(event: IEvent) {
+    super(event);
+    if (event.kind !== DeltaEvent.KIND) {
+      console.warn(`[DeltaEvent] Expected kind ${DeltaEvent.KIND}, got ${event.kind}`);
+    }
+  }
+
+  /**
+   * Relay URL this delta event pertains to
+   */
+  get relay(): string | null {
+    return this.tags.find((tag: NostrTag) => tag[0] === 'r')?.[1] || null;
+  }
+
+  /**
+   * Alias for relay URL
+   */
+  get url(): string | null {
+    return this.relay;
+  }
+
+  /**
+   * Monitor pubkey that published this event
+   */
+  get monitorPubkey(): string {
+    return this.pubkey;
+  }
+
+  /**
+   * Operational status transition (init, up, down)
+   * Only present when status changes
+   */
+  get operationalStatus(): OperationalStatus | null {
+    const status = this.tags.find((tag: NostrTag) => tag[0] === 'status' || tag[0] === 'O')?.[1];
+    if (status === 'init' || status === 'up' || status === 'down') {
+      return status;
+    }
+    return null;
+  }
+
+  /**
+   * RTT (Round Trip Time) for connection open in milliseconds
+   */
+  get rtt(): number | null {
+    const rtt = this.tags.find((tag: NostrTag) => tag[0] === 'rtt-open')?.[1];
+    return rtt ? parseInt(rtt, 10) : null;
+  }
+
+  /**
+   * Retry count for offline relays
+   */
+  get retryCount(): number | null {
+    const count = this.tags.find((tag: NostrTag) => tag[0] === 'retry-count')?.[1];
+    return count ? parseInt(count, 10) : null;
+  }
+
+  /**
+   * Time periods this event represents (e.g., '1h', '24h', '7d')
+   */
+  get periods(): string[] {
+    return this.tags
+      .filter((tag: NostrTag) => tag[0] === 'T')
+      .map((tag: NostrTag) => tag[1]);
+  }
+
+  /**
+   * Whether the relay is online based on operational status
+   * Returns true for 'up' or 'init', false for 'down'
+   */
+  get online(): boolean {
+    const status = this.operationalStatus;
+    if (status === 'up' || status === 'init') {
+      return true;
+    }
+    if (status === 'down') {
+      return false;
+    }
+    // If no status transition, check if RTT is present (implies online)
+    return this.rtt !== null;
+  }
+
+  /**
+   * Check if this event represents a status transition
+   */
+  get isStatusTransition(): boolean {
+    return this.operationalStatus !== null;
+  }
+
+  /**
+   * Get all delta changes from this event
+   * Returns an array of {key, value, type} objects
+   */
+  get deltas(): Array<{ key: string; value: string; type: 'add' | 'remove' | 'change' }> {
+    const deltas: Array<{ key: string; value: string; type: 'add' | 'remove' | 'change' }> = [];
+
+    for (const tag of this.tags) {
+      if (tag[0] === '+' && tag.length >= 3) {
+        deltas.push({ key: tag[1], value: tag[2], type: 'add' });
+      } else if (tag[0] === '-' && tag.length >= 2) {
+        deltas.push({ key: tag[1], value: tag[2] || '', type: 'remove' });
+      } else if (tag[0] === '~' && tag.length >= 3) {
+        deltas.push({ key: tag[1], value: tag[2], type: 'change' });
+      }
+    }
+
+    return deltas;
+  }
+}

package/src/models/Event.ts

@@ -0,0 +1,192 @@
+import { isPRE, isRE } from "@base/utils";
+import { zapSum, zapSumNum } from "@base/utils/nostr";
+import { nip19 } from "nostr-tools";
+
+export enum Kinds {
+  Note = 1,
+  Comment = 1111,
+  Reaction = 7,
+  ReactionUri = 17,
+  ZapReciept = 9725,
+
+  RelayCheck = 30166,
+  RelayMonitorRegistration = 10166,
+  RelayCheckDelta = 1066,
+
+  Wiki = 30818
+}
+
+export type NostrTag = string[];
+
+export const SOURCE: unique symbol = Symbol('SOURCE');
+
+export type IEvent = {
+  id: string;
+  pubkey: string;
+  kind: number;
+  tags: string[][];
+  content: string;
+  signature: string;
+  created_at: number | null;
+  [SOURCE]?: string; 
+}
+
+export type NostrEventOptions = {
+  relays: string[];
+}
+
+export type NostrEventRelatives = {
+  zaps: NostrEvent[],
+  comments: NostrEvent[],
+  reactions: NostrEvent[]
+}
+
+export const defaultNostrEventOptions: NostrEventOptions = { relays: [] };
+
+export class NostrEvent implements IEvent {
+  protected _json: IEvent;
+  protected _options: NostrEventOptions;
+  private _relatives: NostrEventRelatives = {
+    zaps: [],
+    comments: [],
+    reactions: []
+  };
+
+  constructor(event: IEvent, options?: NostrEventOptions) {
+    this._json = event;
+    this._options = options || defaultNostrEventOptions;
+  }
+
+  get isComment(): boolean {
+    return this.kind === 1 && this.tags.some((tag: string[]) => tag[0] === 'e');
+  }
+
+  get id(): string {
+    return this.json.id;
+  }
+
+  get pubkey(): string {
+    return this.json.pubkey;
+  }
+
+  get kind(): number {
+    return this.json.kind;
+  }
+
+  get tags(): string[][] {
+    return this.json.tags;
+  }
+
+  set tags(tags: string[][]) {
+    this.json.tags = tags;
+  }
+
+  get content(): string {
+    return this.json.content;
+  }
+
+  get signature(): string {
+    return this.json.signature;
+  }
+
+  get created_at(): number | null {
+    return this.json.created_at;
+  }
+
+  get json(): IEvent {
+    return this._json;
+  }
+
+  get relays(): string[] {
+    return this._options.relays;
+  }
+
+  get reference(): `naddr1${string}` | `nevent1${string}` {
+    if(isPRE(this.json) || isRE(this.json)) {
+      return this.naddr
+    }
+    else {
+      return this.nevent
+    }
+  }
+
+  get naddr() {
+    const { pubkey, kind, relays } = this;
+    const identifier = this.tags.find((tag: string[]) => tag[0] === 'd')?.[1];
+    if(!identifier) throw new Error('No identifier found in event tags');
+    const pointer: nip19.AddressPointer = { identifier, pubkey, kind, relays }
+    return nip19.naddrEncode(pointer);
+  }
+
+  get nevent() {
+    const pointer: nip19.EventPointer = {
+      id: this.id,
+      relays: this.relays,
+      author: this.pubkey,
+      kind: this.kind
+    }
+    return nip19.neventEncode(pointer);
+  }
+
+  get nnote() {
+    return nip19.noteEncode(this.id);
+  }
+
+  get zaps() {
+    return this._relatives.zaps;
+  }
+
+  get comments() {
+    return this._relatives.comments;
+  }
+
+  get commentsCount(): number {
+    return this._relatives.comments.length;
+  }
+
+  get reactions() {
+    return this._relatives.reactions;
+  }
+
+  get reactionsCount(): number {  
+    return this._relatives.reactions.length;
+  }
+
+  get zapSum(): string {
+    return zapSum(this.zaps);
+  }
+
+  get zapSumNum(): number {
+    return zapSumNum(this.zaps);
+  }
+
+  // addRelatives(events: IEvent[]): void {
+  //   events.forEach(event => this.addRelative(event))
+  // }
+
+  // addRelative(event: IEvent): any {
+  //   const type = relativesKindMap?.[event.kind]
+  //   if(!type) return;
+  //   const model = relativesModelMap?.[type];
+  //   if(!model) return;
+  //   const instance = new model(event)
+  //   this._relatives[ relativesKindMap[event.kind] ].push( instance );
+  //   return instance
+  // }
+}
+
+// export const relativesKindMap: Record<number, keyof NostrEventRelatives>  = {
+//   1: 'comments',
+//   1111: 'comments',
+//   7: 'reactions',
+//   9725: 'zaps'
+// }
+
+// export const relativesModelMap: Record<keyof NostrEventRelatives, any> = {
+//   comments: NostrEvent,
+//   reactions: NostrEvent,
+//   zaps: NostrEvent
+// }
+
+
+

package/src/models/EventEncoded.ts

@@ -0,0 +1,7 @@
+export type IEventEncoded = {
+  id: string;
+  pubkey: string;
+  kind: number;
+  created_at: number | null;
+  encoded: Uint8Array;
+}

package/src/models/Geocode.ts

@@ -0,0 +1,7 @@
+
+export type IGeocode = {
+  code: string;
+  type: string;
+  format: string;
+  length?: number;
+}