@nostrwatch/route66 0.0.1

package/src/utils/hash.ts

@@ -0,0 +1,98 @@
+/**
+ * Determines the type of the given value.
+ */
+function getType(value: any): string {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    if (value instanceof Date) return 'date';
+    if (value instanceof RegExp) return 'regexp';
+    if (value instanceof Map) return 'map';
+    if (value instanceof Set) return 'set';
+    return typeof value;
+}
+
+/**
+ * Serializes any JavaScript value into a deterministic string.
+ * Ensures that object keys are sorted to maintain consistency.
+ */
+function deterministicStringify(value: any): string {
+    const seen = new WeakSet();
+
+    function stringify(val: any): string {
+        const type = getType(val);
+
+        switch (type) {
+            case 'undefined':
+                return 'undefined';
+            case 'null':
+                return 'null';
+            case 'boolean':
+            case 'number':
+            case 'bigint':
+            case 'symbol':
+                return val.toString();
+            case 'string':
+                return JSON.stringify(val);
+            case 'date':
+                return `Date:${val.toISOString()}`;
+            case 'regexp':
+                return `RegExp:${val.toString()}`;
+            case 'function':
+                return `Function:${val.toString()}`;
+            case 'array':
+                return `[${val.map((item: any) => stringify(item)).join(',')}]`;
+            case 'map': {
+                const mapEntries = Array.from(val.entries() as Iterable<[string, number]>).sort(([a], [b]) => {
+                    if (a < b) return -1;
+                    if (a > b) return 1;
+                    return 0;
+                });
+            
+                return `Map:{${mapEntries.map(([k, v]) => `${stringify(k)}=>${stringify(v)}`).join(',')}}`;
+            }                     
+            case 'set':
+                const setEntries = Array.from(val.values()).sort();
+                return `Set:{${setEntries.map(item => stringify(item)).join(',')}}`;
+            case 'object':
+                if (seen.has(val)) {
+                    throw new TypeError('Converting circular structure to string');
+                }
+                seen.add(val);
+                const keys = Object.keys(val).sort();
+                const objString = `{${keys.map(key => `${JSON.stringify(key)}:${stringify(val[key])}`).join(',')}}`;
+                seen.delete(val);
+                return objString;
+            default:
+                return '';
+        }
+    }
+
+    return stringify(value);
+}
+
+/**
+ * Implements the FNV-1a hash algorithm.
+ * Returns a hexadecimal string representation of the hash.
+ */
+function fnv1aHash(str: string): string {
+    let hash = 0x811c9dc5; // FNV offset basis
+    const prime = 0x01000193; // FNV prime
+
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = (hash * prime) >>> 0;
+    }
+
+    // Convert to hexadecimal and pad with zeros if necessary
+    return ('0000000' + hash.toString(16)).slice(-8);
+}
+
+/**
+ * Generates a deterministic hash for any given input.
+ * @param value The input value to hash.
+ * @returns A hexadecimal string representing the hash.
+ */
+export function deterministicHash(value: any): string {
+    const serialized = deterministicStringify(value);
+    return fnv1aHash(serialized);
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './general';
+export * from './classes';
+export * from './events';
+export * from './monitors';
+export * from './geo';
+export * from './hash';
+export * from './encoding';

package/src/utils/monitors.ts

@@ -0,0 +1,4 @@
+export const calculateLiveness = () => {
+
+}
+

package/src/utils/nostr.ts

@@ -0,0 +1,45 @@
+import { IEvent } from "@base/interfaces";
+import { NostrEvent } from "@base/models";
+import Bolt11 from 'light-bolt11-decoder';
+
+export const isPubkey = (value: string): boolean => {
+    const hexRegex = /^[0-9a-fA-F]{64}$/;
+    return hexRegex.test(value);
+}
+
+export type WebsocketUrlType = `wss://${string}` | `ws://${string}`;
+export const getNormalizedWebsocketVariants = (url: WebsocketUrlType): [WebsocketUrlType, WebsocketUrlType] => {
+    const withoutSlash = url.replace(/\/+$/, '') as WebsocketUrlType;
+    const withSlash = withoutSlash + '/' as WebsocketUrlType;
+    return [withoutSlash, withSlash];
+}
+
+export const zapSum = (zaps: IEvent[] | NostrEvent[]): string => {
+    return zapSumString(zapSumNum(zaps));
+}
+
+export const zapSumNum = (zaps: IEvent[] | NostrEvent[]): number => {
+    const bolt11s = zaps.map(zap => {
+            const b11 = zap.tags.find(tag => tag[0] === 'bolt11')?.[1]
+            if(!b11) return null
+            return Bolt11.decode(b11)
+        }).filter( b11 => b11 !== null )
+
+    return Math.round(
+        bolt11s.reduce((acc, b11) => acc += parseInt(
+            b11.sections.find( 
+                section => section?.name === 'amount')?.value || "0"
+            ),
+        0)/1000
+    )
+}
+
+export const zapSumString = (sum: number): string => {
+    if(sum === 0) return '';
+    if (sum < 1000) return sum.toString();
+    const units = ["", "K", "M", "B", "T", "P", "E"];
+    const magnitude = Math.floor(Math.log10(sum) / 3);
+    const precision = magnitude - 1; 
+    const scaled = sum / Math.pow(1000, magnitude); 
+    return `${scaled.toFixed(precision + 1)}${units[magnitude]}`;
+}    

package/src/utils/pfp.ts

@@ -0,0 +1,278 @@
+export class PFP {
+    private static instance: PFP;
+    private canvas: HTMLCanvasElement;
+    private ctx: CanvasRenderingContext2D;
+
+    private constructor(size = 256) {
+        this.canvas = document.createElement("canvas");
+        this.canvas.width = this.canvas.height = size;
+        this.ctx = this.canvas.getContext("2d")!;
+    }
+
+    static generate(seed: string): string {
+        if (!this.instance) this.instance = new PFP();
+        return this.instance.create(seed);
+    }
+
+    private create(seed: string): string {
+        const rand = this.prng(seed);
+        const ctx = this.ctx;
+        const size = this.canvas.width;
+
+        // Clear canvas
+        ctx.clearRect(0, 0, size, size);
+
+        // Generate a harmonious color palette with background variance
+        const palette = this.generatePalette(rand);
+
+        // Draw background with variable color
+        ctx.fillStyle = palette.background;
+        ctx.fillRect(0, 0, size, size);
+
+        // Select a composition based on the seed
+        const compositionIndex = Math.floor(rand() * 3);
+
+        switch (compositionIndex) {
+            case 0:
+                this.drawSymmetricalPattern(rand, palette, size);
+                break;
+            case 1:
+                this.drawFractalPattern(rand, palette, size);
+                break;
+            case 2:
+                this.drawSpiralPattern(rand, palette, size);
+                break;
+        }
+
+        return this.canvas.toDataURL();
+    }
+
+    private drawFractalPattern(rand: () => number, palette: Palette, size: number): void {
+        const ctx = this.ctx;
+
+        // Variable scaling and overflow
+        const scale = 1 + rand() * 1.5;
+        const startX = (rand() * size) - size * (scale - 1) / 2;
+        const startY = (rand() * size) - size * (scale - 1) / 2;
+
+        const maxDepth = 5 + Math.floor(rand() * 3); // Increase max depth to 5–7
+        const initialRadius = (size / 2) * scale * 0.8; // Larger initial radius to occupy more space
+
+        // Determine fractal type based on seed
+        const fractalType = Math.floor(rand() * 3);
+
+        if (fractalType === 0) {
+            this.drawTreeFractal(rand, ctx, startX, startY, -Math.PI / 2, initialRadius, maxDepth, palette);
+        } else if (fractalType === 1) {
+            this.drawCircleFractal(rand, ctx, startX, startY, initialRadius, maxDepth, palette);
+        } else {
+            this.drawPolygonFractal(rand, ctx, startX, startY, initialRadius, maxDepth, palette);
+        }
+    }
+
+    private drawTreeFractal(rand: () => number, ctx: CanvasRenderingContext2D, x: number, y: number, angle: number, length: number, depth: number, palette: Palette): void {
+        if (depth === 0 || length < 2) return;
+
+        const x2 = x + Math.cos(angle) * length;
+        const y2 = y + Math.sin(angle) * length;
+
+        ctx.strokeStyle = palette.colors[depth % palette.colors.length];
+        ctx.lineWidth = depth;
+        ctx.beginPath();
+        ctx.moveTo(x, y);
+        ctx.lineTo(x2, y2);
+        ctx.stroke();
+
+        const branches = 2 + Math.floor(rand() * 2); // 2–3 branches
+        for (let i = 0; i < branches; i++) {
+            const newAngle = angle + (rand() - 0.5) * Math.PI / 2; // Vary angle between branches
+            const newLength = length * (0.5 + rand() * 0.3); // Reduce length
+            this.drawTreeFractal(rand, ctx, x2, y2, newAngle, newLength, depth - 1, palette);
+        }
+    }
+
+    private drawCircleFractal(rand: () => number, ctx: CanvasRenderingContext2D, x: number, y: number, radius: number, depth: number, palette: Palette): void {
+        if (depth === 0 || radius < 2) return;
+
+        ctx.fillStyle = palette.colors[depth % palette.colors.length];
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, Math.PI * 2);
+        ctx.fill();
+
+        const childCount = 3 + Math.floor(rand() * 3); // 3–5 children
+        for (let i = 0; i < childCount; i++) {
+            const angle = (i / childCount) * Math.PI * 2 + rand() * Math.PI / childCount;
+            const newX = x + Math.cos(angle) * radius;
+            const newY = y + Math.sin(angle) * radius;
+            const newRadius = radius * 0.5;
+            this.drawCircleFractal(rand, ctx, newX, newY, newRadius, depth - 1, palette);
+        }
+    }
+
+    private drawPolygonFractal(rand: () => number, ctx: CanvasRenderingContext2D, x: number, y: number, radius: number, depth: number, palette: Palette): void {
+        if (depth === 0 || radius < 3) return;
+
+        const points = 3 + depth % 5; // Vary points between 3–7
+        const rotation = rand() * Math.PI * 2;
+
+        ctx.save();
+        ctx.translate(x, y);
+        ctx.rotate(rotation);
+
+        ctx.beginPath();
+        for (let i = 0; i <= points; i++) {
+            const angle = (i / points) * Math.PI * 2;
+            const px = Math.cos(angle) * radius;
+            const py = Math.sin(angle) * radius;
+            ctx.lineTo(px, py);
+        }
+        ctx.closePath();
+
+        ctx.fillStyle = palette.colors[depth % palette.colors.length];
+        ctx.fill();
+
+        ctx.restore();
+
+        // Recursively draw smaller polygons at each vertex
+        for (let i = 0; i < points; i++) {
+            const angle = (i / points) * Math.PI * 2 + rotation;
+            const newX = x + Math.cos(angle) * radius;
+            const newY = y + Math.sin(angle) * radius;
+            const newRadius = radius * 0.5;
+            this.drawPolygonFractal(rand, ctx, newX, newY, newRadius, depth - 1, palette);
+        }
+    }
+
+    private drawSymmetricalPattern(rand: () => number, palette: Palette, size: number): void {
+        const ctx = this.ctx;
+
+        // Variable scaling and overflow
+        const scale = 1 + rand() * 1.5; // Scale between 1x to 2.5x
+        const centerX = (rand() * size) - size * (scale - 1) / 2;
+        const centerY = (rand() * size) - size * (scale - 1) / 2;
+
+        const layers = 3 + Math.floor(rand() * 3); // 3-5 layers
+
+        for (let i = 0; i < layers; i++) {
+            const radius = (size / 2) * scale * ((layers - i) / layers);
+            const points = 5 + Math.floor(rand() * 4); // 5-8 points
+            const rotation = rand() * Math.PI * 2;
+
+            ctx.save();
+            ctx.translate(centerX, centerY);
+            ctx.rotate(rotation);
+
+            ctx.beginPath();
+            for (let j = 0; j <= points; j++) {
+                const angle = (j / points) * Math.PI * 2;
+                const x = Math.cos(angle) * radius;
+                const y = Math.sin(angle) * radius;
+                ctx.lineTo(x, y);
+            }
+            ctx.closePath();
+
+            ctx.fillStyle = palette.colors[i % palette.colors.length];
+            ctx.fill();
+
+            ctx.restore();
+        }
+    }
+
+    private drawSpiralPattern(rand: () => number, palette: Palette, size: number): void {
+        const ctx = this.ctx;
+
+        // Variable scaling and overflow
+        const scale = 1 + rand() * 1.5;
+        const centerX = (rand() * size) - size * (scale - 1) / 2;
+        const centerY = (rand() * size) - size * (scale - 1) / 2;
+
+        const maxRadius = size / 2 * scale * 1.2;
+        const turns = 3 + Math.floor(rand() * 3); // 3-5 turns
+        const segments = 100;
+
+        // Variable line thickness
+        const baseLineWidth = 2 + rand() * 6; // Line width between 2 to 8
+        ctx.lineWidth = baseLineWidth;
+
+        ctx.beginPath();
+        for (let i = 0; i <= segments * turns; i++) {
+            const t = i / (segments * turns);
+            const angle = t * Math.PI * 2 * turns;
+            const radius = t * maxRadius;
+            const x = centerX + Math.cos(angle) * radius;
+            const y = centerY + Math.sin(angle) * radius;
+            ctx.lineTo(x, y);
+        }
+        ctx.strokeStyle = palette.colors[0];
+        ctx.stroke();
+
+        // Draw shapes along the spiral
+        const shapeCount = 10 + Math.floor(rand() * 10); // 10-20 shapes
+        for (let i = 0; i < shapeCount; i++) {
+            const t = i / shapeCount;
+            const angle = t * Math.PI * 2 * turns;
+            const radius = t * maxRadius;
+            const x = centerX + Math.cos(angle) * radius;
+            const y = centerY + Math.sin(angle) * radius;
+            const shapeRadius = size / 20 * scale + rand() * size / 20 * scale;
+            const points = 3 + Math.floor(rand() * 5);
+            const rotation = rand() * Math.PI * 2;
+
+            ctx.save();
+            ctx.translate(x, y);
+            ctx.rotate(rotation);
+
+            ctx.beginPath();
+            for (let j = 0; j <= points; j++) {
+                const a = (j / points) * Math.PI * 2;
+                const px = Math.cos(a) * shapeRadius;
+                const py = Math.sin(a) * shapeRadius;
+                ctx.lineTo(px, py);
+            }
+            ctx.closePath();
+
+            ctx.fillStyle = palette.colors[(i + 1) % palette.colors.length];
+            ctx.fill();
+
+            ctx.restore();
+        }
+    }
+
+    private generatePalette(rand: () => number): Palette {
+        const baseHue = rand() * 360;
+        const secondaryHue = (baseHue + 30 + rand() * 60) % 360;
+
+        const colors = [
+            `hsl(${baseHue}, 70%, 50%)`,
+            `hsl(${(baseHue + 120) % 360}, 70%, 50%)`,
+            `hsl(${(baseHue + 240) % 360}, 70%, 50%)`,
+        ];
+
+        const backgroundColorIndex = Math.floor(rand() * colors.length);
+        const background = colors.splice(backgroundColorIndex, 1)[0];
+
+        return {
+            background,
+            colors,
+        };
+    }
+
+    private prng(seed: string): () => number {
+        let h = 2166136261 >>> 0;
+        for (let i = 0; i < seed.length; i++) {
+            h ^= seed.charCodeAt(i);
+            h = Math.imul(h, 16777619);
+        }
+        return () => {
+            h += h << 13; h ^= h >>> 7;
+            h += h << 3; h ^= h >>> 17;
+            h += h << 5;
+            return (h >>> 0) / 4294967295;
+        };
+    }
+}
+
+interface Palette {
+    background: string;
+    colors: string[];
+}

package/src/workers/nocap.worker.ts

@@ -0,0 +1 @@
+import Nocap from "@nostrwatch/nocap";

package/tsconfig.browser.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/browser",
+    "declarationDir": "dist/types",
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "module": "ESNext",
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM"]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM"],
+    "declaration": true,
+    "declarationDir": "dist/types",
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "dist/node",
+    "rootDir": "src",
+    "strict": true,
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": false,
+    "resolveJsonModule": true,
+    "baseUrl": "./",
+    // "traceResolution": true,
+    "paths": {
+      "@base/*": ["src/*"],
+      "@core/*": ["src/core/*"],
+      "@models/*": ["src/models/*"],
+      "@transform/*": ["src/transform/*"],
+      "@interfaces/*": ["src/interfaces/*"],
+      "@services/*": ["src/services/*"],
+      "@workers/*": ["src/workers/*"],
+      "@utils/*": ["src/utils/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "adapters"]
+}

package/tsconfig.server.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/server",
+    "module": "CommonJS",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "types": []
+  }
+}