@nostrwatch/route66 0.0.1

package/src/transform/TransformEvent.ts

@@ -0,0 +1,26 @@
+import { IEvent } from "@base/models"
+import { IEventEncoded } from "@base/models/EventEncoded"
+import { decodeByteArrayToJson, encodeJsonToByteArray } from "@base/utils/encoding"
+
+export const TransformEvent = ( event: IEvent | IEventEncoded ): IEvent | IEventEncoded => {
+  //@ts-ignore
+  if(event?.encoded){
+    return decode(event as IEventEncoded)
+  }
+  return encode(event as IEvent)
+}
+
+const decode = ( event: IEventEncoded ): IEvent => {
+  const json = decodeByteArrayToJson(event.encoded)
+  return {...event, ...json}  
+}
+
+const encode = ( event: IEvent ): IEventEncoded => {
+  const { id, pubkey, kind, created_at } = event
+  const encoded = encodeJsonToByteArray({ 
+    tags: event.tags,
+    content: event.content,
+    signature: event.signature
+  });
+  return { id, pubkey, kind, created_at, encoded }
+}

package/src/transform/TransformMonitors.ts

@@ -0,0 +1,91 @@
+import { IEvent, IMonitor, modelDefaults } from '@models/index';
+import { geocodeTransform, iGeocodeToArray } from './TransformRelays';
+import { isGeohash } from '@base/utils';
+
+export type IdbReadyMonitorData = { 
+  event?: IEvent;
+  monitor?: IMonitor;
+}
+
+export const transform10166 = async (_event: IEvent): Promise<IdbReadyMonitorData> => {  
+  const res: IdbReadyMonitorData = {}
+
+  const eventRecord = k10166ToIEvent(_event)
+  const parsedMonitor = n66IEventToIMonitor( eventRecord)
+
+  if(eventRecord) res.event = eventRecord
+  if(parsedMonitor) res.monitor = parsedMonitor
+
+  return res
+}
+
+export const k10166ToIEvent = (_event: IEvent): IEvent => {
+  const { pubkey, created_at, id, kind, tags, content, signature } = _event;
+  const event: IEvent = {
+    id,
+    kind,
+    pubkey,
+    created_at,
+    tags,
+    content,
+    signature
+  }
+  return event
+}
+
+export const n66IEventToIMonitor = (event: IEvent): IMonitor => {
+  const { pubkey, id:eventId } = event;
+
+  const frequency: number = getFrequency(event);
+  const checks: string[] | null = getChecks(event)
+  const geohash: string | null = getGeohash(event)
+  const geocode = iGeocodeToArray(geocodeTransform(event))
+
+  const monitor = { 
+    pubkey,
+    eventId,
+    checks,
+    frequency,
+    geohash,
+    geocode
+  }
+
+  return {...modelDefaults<IMonitor>(), ...monitor} as IMonitor
+}
+
+const getFrequency = (event: IEvent): number => {
+  let f = -1
+  try{
+    const f_ = event.tags.find( tag => tag[0] === 'frequency' )?.[1];
+    if(f_) f = parseInt(f_)
+  }
+  catch(e){
+    console.warn(`frequency did not validate for monitor: ${event.pubkey}`)
+  }
+  return f;
+}
+
+const getGeohash = (event: IEvent): string | null => {
+  const geohashes = event.tags.filter( t => t[0] === 'g' && isGeohash(t[1]) )
+  return geohashes.reduce((longest, t) => {
+    const key = t[0];
+    const value = t[1];
+    if (value.length > (longest?.length || 0)) {
+      return value;
+    }
+    return longest
+  }, null as string | null);
+};
+
+const getChecks = (event: IEvent): string[] | null => {
+  const checks = event.tags.reduce( (acc, t) => {
+    const key = t[0];
+    const value = t[1];
+    const isCheck = key === 'c';
+    if(isCheck) acc.push(value)
+    return acc
+  }, [] as string[] );
+  return checks ?? null
+}
+
+export default transform10166;

package/src/transform/TransformRelays.ts

@@ -0,0 +1,327 @@
+import { IRelay, ICheck, IEvent, INip11, IGeocode, modelDefaults } from '@models/index';
+
+import { 
+  GeoCodesObjectRaw, 
+  ISO3166Format, 
+  ISO3166Type, 
+  RawGeoCode, 
+  RawGeoCodes 
+} from '@interfaces/index';
+
+import { 
+  getUrlFromEvent, 
+  getNetworkFromEvent, 
+  extractGeoCodes 
+} from '@utils/index';
+
+export type IdbReadyRelayData = { 
+  event?: IEvent,
+  relay?: IRelay, 
+  check?: ICheck,
+  nip11?: INip11,
+  geocodes?: IGeocode[]
+}
+
+export const transform30166 = async (_event: IEvent): Promise<IdbReadyRelayData> => {  
+  const res: IdbReadyRelayData = {}
+
+  const eventRecord = k30166ToIEvent(_event)
+
+  const relay: string | undefined = getUrlFromEvent(eventRecord as IEvent)
+  const network: string | undefined = getNetworkFromEvent(eventRecord as IEvent) ?? 'unknown'
+
+  // if(!relay || !network) {
+  //   console.error(`Event did not contain relay or network: ${eventRecord.id}, relay: ${relay}, network: ${network}`)
+  //   return res;
+  // }
+
+  if(!relay) {
+    console.error(`Event did not contain relay or network: ${eventRecord.id}, relay: ${relay}`)
+    return res;
+  }
+  
+  const parsedRelay = n66IEventToIRelay(relay, network, eventRecord)
+  const parsedNip11 = await n66IEventToNip11(relay, eventRecord)
+  const parsedGeocodes = n66IEventToIGeocodes(eventRecord)
+  const parsedCheck = k30166ToICheck(eventRecord, parsedNip11, parsedGeocodes)
+
+  if(eventRecord) res.event = eventRecord
+  if(parsedCheck) res.check = parsedCheck
+  if(parsedRelay) res.relay = parsedRelay
+  if(parsedNip11) res.nip11 = parsedNip11
+  if(parsedGeocodes) res.geocodes = parsedGeocodes
+
+  return res
+}
+
+export const k30166ToIEvent = (_event: IEvent): IEvent => {
+  const { pubkey, created_at, id, kind, tags, content, signature } = _event;
+  const event: IEvent = {
+    id,
+    kind,
+    pubkey,
+    created_at,
+    tags,
+    content,
+    signature
+  }
+  return event
+}
+
+export const k30166ToICheck = (event: IEvent, nip11?: INip11, geocode_: IGeocode[] = []): ICheck => {
+  const { pubkey:monitorPubkey, created_at:created_at_ } = event;
+
+  const nid = event.id;
+
+  const created_at = created_at_ as number 
+
+  const relay = getUrlFromEvent(event);
+  const network = getNetworkFromEvent(event);
+  const rtt = getRtt(event);
+  
+  const { ipv4, ipv6 } = getIps(event);
+  const { isp, as, asname } = getIsp(event);
+  const geohash = getGeohash(event);
+
+  const geocode = iGeocodeToArray(geocode_)
+  
+  let operatorPubkey = null,
+      supportedNips = null, 
+      software = null,
+      version = null,
+      paymentRequired = null,
+      authRequired = null;
+  
+  if(nip11){
+    operatorPubkey = nip11.json?.pubkey ?? null;
+    supportedNips = nip11.json?.supported_nips ?? null;
+    software = nip11.json?.software ?? null;
+    version = nip11.json?.version ?? null;
+    paymentRequired = nip11.json?.limitation?.payment_required? 1: 0;
+    authRequired = nip11.json?.limitation?.authRequired? 1: 0;
+  }
+
+  const relayCheck = { 
+    nid, 
+    relay,
+    monitorPubkey, 
+
+    created_at,
+
+    network,
+    rtt, 
+
+    geohash,
+    geocode, 
+
+    operatorPubkey,
+    supportedNips,
+    software,
+    version,
+
+    paymentRequired,
+    authRequired,
+
+    isp,
+    as,
+    asname,
+
+    ipv4,
+    ipv6,
+  }
+  return {...modelDefaults<ICheck>(), ...relayCheck} as ICheck
+}
+
+export const iGeocodeToArray = (geocode_: IGeocode[]): string[] => {
+  return geocode_.reduce((acc: string[], geocode: IGeocode) => {
+    acc.push(geocode.code);
+    return acc;
+  }, [] as string[]);
+}
+
+const getGeohash = (event: IEvent): string | null => {
+  return event.tags.reduce((longest, t) => {
+    const key = t[0];
+    const value = t[1];
+    const isGeohash = key === 'g';
+
+    if (isGeohash && value.length > (longest?.length || 0)) {
+      return value;
+    }
+
+    return longest;
+  }, null as string | null);
+};
+
+const getRtt = (event: IEvent): number | null => {
+  let rtt = event.tags
+    .find((t) => {
+      const key = t[0];
+      if (key === 'rtt-open') {
+        return true
+      }
+    })?.[1]
+  if(!rtt) return null
+  let rttN
+  try{
+    rttN = parseInt(rtt)
+  }
+  catch(e){
+    console.warn(`rtt did not validate for monitor: ${event.pubkey}`)
+  }
+  return rttN ?? null
+}
+
+const getIps = (event: IEvent): Record<string, string[]> => {
+  return event.tags.reduce((acc, t) => {
+    const key = t[0];
+    const value = t[1];
+    const label = t[2];
+    const isLabel = key === 'l';
+  
+    if (isLabel && label.includes('ipv4')) {
+      acc.ipv4.push(value);
+    }
+    if (isLabel && label.includes('ipv6')) {
+      acc.ipv6.push(value);
+    }
+
+    return acc;
+  }, { ipv4: [], ipv6: [] } as Record<string, string[]>);
+}
+
+const getIsp = (event: IEvent): Record<string, string | null> => {
+  return event.tags.reduce((acc, t) => {
+    const key = t[0];
+    const value = t[1];
+    const label = t[2];
+    const isLabel = key === 'l';
+  
+    if (isLabel && label.includes('isp')) {
+      acc.isp = value;
+    }
+    else if (isLabel && label.includes('asname')) {
+      acc.asname = value;
+    }
+    else if (isLabel && label.includes('as')) {
+      acc.as = value;
+    }
+    return acc;
+  }, { isp: null, as: null, asname: null } as Record<string, string | null>);
+}
+
+export const n66IEventToIRelay = (relay: string, network: string, event: IEvent): IRelay | undefined => {
+  const { pubkey, created_at:lastSeen } = event;
+
+  const _relay = {
+    relay,
+    lastSeen: lastSeen as number,
+    network
+  }
+  return {...modelDefaults<IRelay>(), ..._relay} as IRelay
+}
+
+const n66IEventToNip11 = async (relay: string, event: IEvent): Promise<INip11 | undefined> => {
+  const { pubkey:monitorPubkey, id:nid, created_at } = event;
+
+  if(!created_at) return
+  let json
+  try {
+    json = JSON.parse(event.content)
+  } catch(e){
+    console.warn(`could not parse nip-11 for ${relay}`)
+    return 
+  }
+
+  if(!json || !(Object.keys(json)?.length > 0)) return undefined
+  
+  let hash = null; 
+  try {
+    hash = await hashObject(json);
+  } catch (error) {
+    console.error('Error hashing object:', error);
+    return undefined
+  }
+
+  const inip11 = {
+    relay,
+    nid,
+    monitorPubkey,
+    created_at,
+    hash,
+    json, 
+  }
+  return {...modelDefaults<INip11>(), ...inip11}
+}
+
+export const geocodeTransform = ( event: IEvent ): IGeocode[] => {
+  const codes: GeoCodesObjectRaw = extractGeoCodes(event as IEvent)
+  const cc = parseGeocodes(codes.countryCode, ISO3166Type.CountryCode)
+  const rc = parseGeocodes(codes.regionCode, ISO3166Type.RegionCode)
+  const res: IGeocode[] = []
+  if(cc) res.push(...cc)
+  if(rc) res.push(...rc)
+  return res;
+}
+
+export const parseGeocodes = (codes: RawGeoCodes, type: ISO3166Type): IGeocode[] | undefined => {
+  const geocodeEntries: IGeocode[] = [];
+  if(!codes) return
+  (codes as RawGeoCodes).forEach( (code: RawGeoCode) => { 
+    geocodeEntries.push( parseGeocode(type, code) ) 
+  })
+  return geocodeEntries
+}
+
+export const parseGeocode = (type: ISO3166Type, code: RawGeoCode): IGeocode => {
+  const isNumeric = !isNaN(Number(code))
+  const ignoreLength = isNumeric || type === ISO3166Type.RegionCode? true: false
+  if(typeof code !== 'string') code = String(code)
+  return {
+    code, 
+    type: type,
+    format: isNumeric? ISO3166Format.Numeric: ISO3166Format.Alpha,
+    length: ignoreLength? -1: String(code).length
+  }
+}
+
+// const n66IEventToSsl = async (event: IEvent): Promise<ISsl | undefined> => {
+//   const { pubkey:monitorPubkey, id:nid, created_at:created_at } = event;
+
+//   const relay = getUrlFromEvent(event)
+
+//   if(!relay) {
+//     console.error(`Event did not contain relay: ${event.id}, relay: ${relay}`)
+//     return
+//   }
+  
+//   if(!cert || !relay) return undefined
+//   const hash = await hashString(cert)
+
+//   const ssl: ISsl = {
+//     nid,
+//     created_at,
+//     relay,
+//     monitorPubkey,
+//     hash,
+//     cert,
+//   }
+
+//   return ssl
+// }
+
+const n66IEventToIGeocodes = (event: IEvent): IGeocode[] => {
+  return geocodeTransform(event)
+}
+
+
+export const hashObject = async (obj: Record<string, any>): Promise<string> => {
+  const canonicalJson = JSON.stringify(obj, Object.keys(obj).sort());
+  const buffer = new TextEncoder().encode(canonicalJson);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+  return hashHex;
+}
+
+export default transform30166;

package/src/transform/index.ts

@@ -0,0 +1,3 @@
+export * from './TransformMonitors';
+export * from './TransformRelays';
+export * from './TransformEvent';

package/src/utils/SyncKeys.ts

@@ -0,0 +1,12 @@
+export class SyncKeys {
+    constructor(private pubkey: string) {}
+    /**
+     * Generates a key for a given kind and rangeKey.
+     * @param kind The kind of event.
+     * @param rangeKey The specific range ('since' | 'until' | etc.).
+     * @returns The generated key as a string.
+     */
+    generateKey(key: string, kind: number, rangeKey: string): string {
+      return `${this.pubkey}:${kind}:${key}:${rangeKey}`;
+    }
+}

package/src/utils/classes.ts

@@ -0,0 +1,48 @@
+type Constructor<T = any> = new (...args: any[]) => T;
+
+/**
+ * Retrieves the inheritance chain of a given class constructor.
+ * @param cls - The class constructor to inspect.
+ * @returns An array of class constructors representing the inheritance chain.
+ */
+export const getInheritanceChain = (cls: Constructor): Function[] => {
+  const chain: Function[] = [];
+  let currentProto = Object.getPrototypeOf(cls.prototype);
+
+  // Traverse the inheritance chain
+  while (currentProto && currentProto.constructor && currentProto.constructor !== Object) {
+    const constructor = currentProto.constructor;
+
+    // Only add valid class constructors (skip empty names or functions)
+    if (constructor.name && constructor !== Function) {
+      chain.push(constructor);
+    }
+    currentProto = Object.getPrototypeOf(currentProto);
+  }
+
+  // Add Object if necessary, to denote the end of the chain
+  if (!chain.includes(Object)) {
+    chain.push(Object);
+  }
+  
+  return chain;
+};
+
+/**
+ * Retrieves the inheritance chain as an array of class names.
+ * @param cls - The class constructor to inspect.
+ * @returns An array of class names representing the inheritance chain.
+ */
+export const getInheritanceChainArray = <T>(cls: Constructor<T>): string[] => {
+  return getInheritanceChain(cls).map(constructor => constructor.name).filter(Boolean); // Filter out empty names
+};
+
+/**
+ * Retrieves the inheritance chain from an instance.
+ * @param instance - The class instance to inspect.
+ * @returns An array of class names representing the inheritance chain.
+ */
+export const getInheritanceChainFromInstance = <T extends object>(instance: T): string[] => {
+  const constructor = instance.constructor as Constructor<T>;
+  return getInheritanceChainArray(constructor);
+};

package/src/utils/encoding.ts

@@ -0,0 +1,16 @@
+export const encodeJsonToByteArray = (jsonObject: any): Uint8Array => {
+  const jsonString = JSON.stringify(jsonObject);
+  const encoder = new TextEncoder();
+  return encoder.encode(jsonString);
+}
+
+export const decodeByteArrayToJson = (byteArray: Uint8Array): any => {
+  const decoder = new TextDecoder();
+  const jsonString = decoder.decode(byteArray);
+  return JSON.parse(jsonString);
+}
+
+export const encodeJsonToUrlSafe = async (json: any) => {
+  const JSURL = (await import('jsurl2'))?.default;
+  return JSURL.stringify(json);
+}

package/src/utils/events.ts

@@ -0,0 +1,29 @@
+import { IEvent } from "@models/Event";
+
+export const getUrlFromEvent = (event: IEvent): string | undefined => {
+  let relay: string | undefined;
+  try {
+    relay = new URL(event.tags.find( t => t[0] === 'd')?.[1] ?? "").toString()
+  }
+  catch(e) {
+    console.error('Error parsing relay from event id:', event.id, "error:", e)  
+  }
+  return relay
+}
+
+export const getNetworkFromEvent = (event: IEvent): string | undefined => {
+  return event.tags.find( t => t[0] === 'n')?.[1]
+}
+
+export const isPRE = (ev: IEvent): boolean => {
+  return ev.kind >= 30000 && ev.kind < 40000
+}
+
+export const isRE = (ev: IEvent): boolean => {
+  const legacyReplaceableKinds = [0, 3, 41];
+  return (ev.kind >= 10000 && ev.kind < 20000) || legacyReplaceableKinds.includes(ev.kind)
+}
+
+export const isEphemeral = (ev: IEvent): boolean => {
+  return ev.kind >= 20000 && ev.kind < 30000
+}

package/src/utils/general.ts

@@ -0,0 +1,101 @@
+// import type { Table } from 'dexie';
+
+export const hashObject = async (obj: Record<string, any>): Promise<string> => {
+  const canonicalJson = JSON.stringify(obj, Object.keys(obj).sort());
+  const buffer = new TextEncoder().encode(canonicalJson);
+  const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+  return hashHex;
+}
+
+export const nHoursAgo = (hrs: number): number => Math.floor((Date.now() - hrs * 60 * 60 * 1000) / 1000);
+
+export const normalizeUrl = (url: string) => {
+  const parsedUrl = new URL(url);
+  parsedUrl.search = '';
+  parsedUrl.hash = '';
+  return parsedUrl.toString();
+};
+
+export const isGeohash = (input: string): boolean => {
+  // Geohashes are usually between 1 and 12 characters long and only use base32 (no a, i, l, o).
+  const geohashRegex = /^[0-9a-z]{1,20}$/;
+  return geohashRegex.test(input);
+  return true;
+}
+
+export const applyMixins = (derivedCtor: any, baseCtors: any[]) => {
+  baseCtors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      // Check for potential method conflicts
+      if (!derivedCtor.prototype.hasOwnProperty(name)) {
+        Object.defineProperty(
+          derivedCtor.prototype,
+          name,
+          Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
+            Object.create(null)
+        );
+      } else {
+        console.warn(`Method ${name} already exists in ${derivedCtor.name} and will not be overwritten.`);
+      }
+    });
+  });
+};
+
+
+export const safeApplyMixins = (derivedCtor: any, baseCtors: any[]) => {
+  baseCtors.forEach(baseCtor => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
+      // Get the property descriptor for better control over method copying
+      const descriptor = Object.getOwnPropertyDescriptor(baseCtor.prototype, name);
+
+      if (!derivedCtor.prototype.hasOwnProperty(name)) {
+        // Log what's being copied for debugging
+        ////console.log(`Copying ${name} from ${baseCtor.name} to ${derivedCtor.name}`);
+        
+        if (descriptor) {
+          // Use defineProperty to preserve method/function behavior, getters, setters, etc.
+          Object.defineProperty(derivedCtor.prototype, name, descriptor);
+        } else {
+          // Default fallback if no descriptor is found (rare case)
+          derivedCtor.prototype[name] = baseCtor.prototype[name];
+        }
+      } else {
+        // Log what is skipped due to an existing method with the same name
+        ////console.log(`Skipping ${name} - already exists in ${derivedCtor.name}`);
+      }
+    });
+  });
+};
+
+
+
+
+// export const allOf = <T>(table: Table<T, any>, multiValueProp: keyof T & string, keys: (T[keyof T & string])[]): Promise<T[]> => {
+//   if (keys.length === 0) return Promise.resolve([]);
+
+//   const [dbKey, ...filteredKeys] = keys;
+//   return table.where(multiValueProp).equals(dbKey as any).toArray().then((dbResult: T[]) =>
+//     filteredKeys.reduce((result: T[], key: T[keyof T & string]) =>
+//       result.filter((doc: T) => Array.isArray(doc[multiValueProp]) && (doc[multiValueProp] as any[]).includes(key)),
+//       dbResult
+//     )
+//   );
+// };
+
+export const hashString = async (input: string) => {
+  if (typeof window !== 'undefined' && window.crypto && window.crypto.subtle) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(input);
+      const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+      return hashHex;
+  } else if (typeof require === 'function') {
+      const crypto = require('crypto');
+      return crypto.createHash('sha256').update(input, 'utf8').digest('hex');
+  } else {
+      throw new Error('Environment not supported');
+  }
+}

package/src/utils/geo.ts

@@ -0,0 +1,19 @@
+import { IEvent } from "@models/Event"
+import { GeoCodesObjectRaw, ISO3166Type } from "@base/interfaces/TISO13166"
+
+export const extractGeoCodesByType = ( event: IEvent, type: ISO3166Type ): (string | number)[] => {
+  return event.tags
+          .filter((tag: string[]) => tag[0] === 'l' && tag[2] === type)
+          .map((tag: string[]) => tag[1])
+          .filter((tag: string) => tag !== undefined) || []
+}
+
+export const extractGeoCodes = ( event: IEvent ): GeoCodesObjectRaw => {
+  let countryCode: (string | number)[] = [];
+  let regionCode: (string | number)[] = [];
+
+  countryCode = extractGeoCodesByType(event, ISO3166Type.CountryCode)
+  regionCode = extractGeoCodesByType(event, ISO3166Type.RegionCode)
+
+  return { countryCode, regionCode } as GeoCodesObjectRaw
+}