@nostrwatch/memory-relay 1.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Sandwich Farm LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

package/README.md

@@ -0,0 +1,275 @@
+# @nostrwatch/memory-relay
+
+In-memory Nostr relay implementation for testing and SvelteKit application state.
+
+[![npm version](https://img.shields.io/npm/v/@nostrwatch/memory-relay?style=flat-square&label=npm)](https://www.npmjs.com/package/@nostrwatch/memory-relay)
+[![License](https://img.shields.io/github/license/sandwichfarm/nostr-watch?style=flat-square)](LICENSE)
+[![Status](https://img.shields.io/badge/status-alpha-orange?style=flat-square)](https://github.com/sandwichfarm/nostr-watch)
+[![Runtime](https://img.shields.io/badge/runtime-browser-blue?style=flat-square)](https://github.com/sandwichfarm/nostr-watch)
+
+## Overview
+
+`@nostrwatch/memory-relay` provides an in-memory store for Nostr events (signed JSON objects that form the protocol's fundamental data unit) without any network layer or disk persistence. It is used in tests to simulate relay behavior and in SvelteKit applications to hold reactive event collections without a backend relay connection.
+
+The package exports two classes: `AbstractMemoryRelay` — a generic base class with filter-aware query, insert, count, and delete operations — and `SvelteMemoryRelay`, which extends `AbstractMemoryRelay` to back all event storage with a Svelte `Writable` store, making the event collection reactive and compatible with Svelte's `$` syntax and `derived` stores.
+
+A **relay** in Nostr is a WebSocket server that stores and forwards events. This package emulates the data model of a relay in memory without the network transport.
+
+## Installation
+
+```sh
+pnpm add @nostrwatch/memory-relay
+```
+
+Or with npm:
+
+```sh
+npm install @nostrwatch/memory-relay
+```
+
+## Quick Start
+
+```ts
+import {AbstractMemoryRelay} from '@nostrwatch/memory-relay'
+import type {Filter} from 'nostr-tools'
+
+class MyRelay extends AbstractMemoryRelay {
+  async init(): Promise<void> {}
+}
+
+const relay = new MyRelay()
+
+// Insert a Nostr event
+relay.event({id: 'abc123', kind: 1, created_at: 1700000000, content: 'hello', tags: [], pubkey: 'pub1'})
+
+// Query with a filter
+const results = relay.req('sub1', [{kinds: [1]}])
+console.log(relay.count([{kinds: [1]}]))
+// 1
+```
+
+## API
+
+### `AbstractMemoryRelay`
+
+```ts
+abstract class AbstractMemoryRelay<
+  Input extends BaseEvent = any,
+  Output extends BaseEvent = any,
+  OutputSingle = Output,
+  OutputCollection = any,
+  OutputCount = any
+>
+```
+
+Abstract base class for in-memory event storage. Extend this class and implement `init()` to create a concrete relay. Subclasses may override `formatCollection()` to shape query results, and register `qualify` and `instantiate` callbacks to control which events are stored and how they are transformed on insert.
+
+#### `abstract init(): Promise<void>`
+
+Called once before the relay is used. Implement to perform any async setup (e.g. loading seed events from storage). Must return a resolved promise if no setup is needed.
+
+---
+
+#### Event writes
+
+**`event(ev: Input): boolean`**
+
+Inserts a single event. Returns `true` if the event was inserted, `false` if it was rejected (by the qualify callback or because a newer replaceable event already exists).
+
+**`eventBatch(evs: Input[]): number`**
+
+Inserts multiple events. Returns the count of events actually inserted.
+
+**`maybeInsert(event: Input): number`**
+
+Lower-level insert: checks `shouldInsert()`, then stores the event. Returns `1` if inserted, `0` otherwise.
+
+---
+
+#### Event reads
+
+**`req(id: string, filters: Filter[], format?: boolean): OutputCollection | Output[]`**
+
+Queries the store against one or more Nostr filters (a filter is a JSON object with fields like `kinds`, `authors`, `since`, `until`, `#e`, etc.). Returns all matching events. When `format` is `true` (default), passes results through `formatCollection()`.
+
+**`get(key: string): Output | undefined`**
+
+Returns a single event by its internal storage key (event ID or `kind:pubkey` for replaceable events).
+
+**`count(filters: Filter[]): OutputCount`**
+
+Returns the number of events that match the given filters.
+
+**`summary(): Record<string, number>`**
+
+Returns a map of `{ kind: count }` for all stored events. Useful for debugging and test assertions.
+
+---
+
+#### Event deletes
+
+**`delete(filters: Filter[]): string[]`**
+
+Deletes all events matching the filters. Returns the keys of deleted events.
+
+**`wipe(): Promise<void>`**
+
+Clears all stored events.
+
+**`destroy(): void`**
+
+Calls `wipe()` and releases resources.
+
+---
+
+#### Existence checks
+
+**`exists(note: Input | string): boolean`**
+
+Returns `true` if the given event (or event ID string) is present in the store.
+
+**`noteExists(note: Input): boolean`**
+
+Returns `true` if the given event object is in the store.
+
+**`idExists(id: string): boolean`**
+
+Returns `true` if the given event ID string is in the store.
+
+---
+
+#### Lifecycle callbacks
+
+**`on(event: 'qualify' | 'instantiate', listener): void`**
+
+Registers a callback for event lifecycle hooks:
+
+- `qualify(event, key, relay)` — return `false` to reject an event before insert; `true` to accept
+- `instantiate(event, key, relay)` — transform an input event into the stored output type; return the transformed event
+
+**`off(event: 'qualify' | 'instantiate'): void`**
+
+Removes the registered callback for the given lifecycle hook.
+
+---
+
+#### Serialization
+
+**`dump(): Promise<Uint8Array>`**
+
+Serializes all stored events to a UTF-8 JSON byte array. Useful for snapshotting relay state in tests.
+
+---
+
+#### Properties
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `events` | `Map<string, Output>` | Direct access to the event store |
+| `nip11s` | `Map<string, any>` | NIP-11 info document cache keyed by relay URL |
+| `highestTimestamp` | `number[]` | Per-filter highest `created_at` seen during `req()` |
+| `lowestTimestamp` | `number[]` | Per-filter lowest `created_at` seen during `req()` |
+| `debounceMS` | `number` | Debounce interval in milliseconds (default `1000`) |
+
+---
+
+### `SvelteMemoryRelay`
+
+```ts
+class SvelteMemoryRelay<
+  InputEvent extends BaseEvent,
+  OutputEvent extends BaseEvent,
+  OutputSingle extends Readable<OutputEvent> = Readable<OutputEvent>,
+  OutputCollection extends Readable<OutputEvent[]> = Readable<OutputEvent[]>,
+  OutputCount extends Readable<number> = Readable<number>
+> extends AbstractMemoryRelay<InputEvent, OutputEvent, OutputSingle, OutputCollection, OutputCount>
+```
+
+Extends `AbstractMemoryRelay` to back event storage with a Svelte `Writable<Map<string, OutputEvent>>` store. All mutations (`maybeInsert`, `wipe`, `_delete`) update the store atomically, triggering reactive updates in subscribing components.
+
+Import from the `svelte` subpath:
+
+```ts
+import {SvelteMemoryRelay} from '@nostrwatch/memory-relay/svelte'
+import {writable} from 'svelte/store'
+```
+
+#### Constructor
+
+```ts
+new SvelteMemoryRelay(store: Writable<Map<string, OutputEvent>>)
+```
+
+Pass an existing `Writable` store. The relay reads and writes through the store reference, so external subscribers see changes immediately.
+
+**Example (SvelteKit component):**
+
+```ts
+import {SvelteMemoryRelay} from '@nostrwatch/memory-relay/svelte'
+import {writable, derived} from 'svelte/store'
+
+const eventStore = writable(new Map())
+const relay = new SvelteMemoryRelay(eventStore)
+await relay.init()
+
+// Reactive query — updates whenever events are inserted or deleted
+const kind1Events = relay.$req('sub1', [{kinds: [1]}])
+
+// In Svelte template: {#each $kind1Events as event}
+```
+
+#### Reactive query methods
+
+**`$req(id: string, filters: Filter[], format?: boolean): OutputCollection`**
+
+Returns a `Readable<OutputEvent[]>` derived from the store. Updates reactively whenever the store changes.
+
+**`$get(key: string): OutputSingle | undefined`**
+
+Returns a `Readable<OutputEvent>` for a single event by key. Updates reactively.
+
+**`$count(filters: Filter[]): OutputCount`**
+
+Returns a `Readable<number>` that emits the count of matching events. Updates reactively.
+
+#### Properties
+
+**`store: Writable<Map<string, OutputEvent>>`**
+
+Direct access to the underlying Svelte store. Subscribe to it to react to any event store change.
+
+---
+
+### `BaseEvent`
+
+```ts
+interface BaseEvent {
+  id?: string
+  kind?: number
+  created_at?: number
+  tags?: string[][]
+  pubkey?: string
+  content?: string
+  sig?: string
+}
+```
+
+Minimum shape required by the relay internals. Use `nostr-tools`' `Event` type for full Nostr event compliance.
+
+## Known Limitations
+
+No known limitations at this time.
+
+## Agent Skills
+
+No agent skills defined yet for this package.
+
+## Related Packages
+
+- [`@nostrwatch/worker-relay`](../worker-relay/README.md) — persistent web worker relay using sqlite-wasm and OPFS; use this when you need durability across page reloads
+- [`@nostrwatch/websocket`](../websocket/README.md) — cross-platform WebSocket client; pairs with memory-relay in integration tests that simulate a real relay connection
+- [`apps/gui`](../../apps/gui/README.md) — SvelteKit app that uses `SvelteMemoryRelay` for local event caching and reactive UI updates
+
+## License
+
+[MIT](../../LICENSE)

package/dist/abstract.d.ts

@@ -0,0 +1,38 @@
+import { Filter } from "nostr-tools";
+import { AbstractMemoryRelayCallback } from "./types.js";
+import { BaseEvent } from "./types.js";
+export declare abstract class AbstractMemoryRelay<Input extends BaseEvent = any, Output extends BaseEvent = any, OutputSingle = Output, OutputCollection = any | any[], OutputCount = any> {
+    private listeners;
+    protected _events: Map<string, Output>;
+    protected _nip11s: Map<string, any>;
+    highestTimestamp: number[];
+    lowestTimestamp: number[];
+    debounceMS: number;
+    protected set events(e: Map<string, Output>);
+    get events(): Map<string, Output>;
+    get nip11s(): Map<string, any>;
+    abstract init(): Promise<void>;
+    on(event: "qualify" | "instantiate", listener: AbstractMemoryRelayCallback<this, Output>): void;
+    off(event: "qualify" | "instantiate"): void;
+    protected instantiateEvent(event: Input, key: string): Output;
+    protected qualifyEvent(event: Input, key: string): boolean;
+    exists(note: Input | string): boolean;
+    noteExists(note: Input): boolean;
+    idExists(id: string): boolean;
+    count(filters: Filter[]): OutputCount;
+    summary(): Record<string, number>;
+    dump(): Promise<Uint8Array>;
+    close(): void;
+    wipe(): Promise<void>;
+    maybeInsert(event: Input): number;
+    event(ev: Input): boolean;
+    eventBatch(evs: Input[]): number;
+    setTimestampRange(event: Input | Output | BaseEvent, index?: number): void;
+    formatCollection(collection: Output[]): OutputCollection;
+    req(id: string, filters: Filter[], format?: boolean): OutputCollection | Output[];
+    get(key: string): Output | undefined;
+    delete(filters: Filter[]): string[];
+    _delete(keys: string[]): string[];
+    destroy(): void;
+    protected shouldInsert(event: Input): boolean;
+}

package/dist/esm/abstract.mjs

@@ -0,0 +1,7 @@
+import {
+  AbstractMemoryRelay
+} from "./chunk-QC3J2K4S.mjs";
+export {
+  AbstractMemoryRelay
+};
+//# sourceMappingURL=abstract.mjs.map

package/dist/esm/abstract.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/esm/chunk-QC3J2K4S.mjs

@@ -0,0 +1,225 @@
+// src/utils.ts
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+var eventType = (event) => {
+  if (isReplaceableKind(event.kind)) {
+    return "replaceable";
+  } else if (isParameterizedReplaceableKind(event.kind)) {
+    return "parameterized";
+  } else {
+    return "event";
+  }
+};
+var eventAddr = (event, type) => {
+  let { pubkey, kind } = event;
+  type = type ?? eventType(event);
+  pubkey = pubkey.slice(0, 16);
+  if (type === "parameterized") {
+    const dtag = event.tags.find((t) => t[0] === "d")?.[1];
+    const key = `${pubkey}:${kind}:${dtag}`;
+    return key;
+  } else if (type === "replaceable") {
+    const key = `${pubkey}:${kind}`;
+    return key;
+  }
+};
+var eventKey = (event, type) => {
+  type = type ?? eventType(event);
+  if (type === "replaceable") {
+    return eventAddr(event, type);
+  } else if (type === "parameterized") {
+    return eventAddr(event, type);
+  } else {
+    return event.id;
+  }
+};
+var eventIdData = (event) => {
+  const type = eventType(event);
+  return {
+    type,
+    key: eventKey(event, type)
+  };
+};
+function eventMatchesFilter(ev, filter) {
+  if (filter.since && ev.created_at < filter.since) {
+    return false;
+  }
+  if (filter.until && ev.created_at > filter.until) {
+    return false;
+  }
+  if (!(filter.ids?.includes(ev.id) ?? true)) {
+    return false;
+  }
+  if (!(filter.authors?.includes(ev.pubkey) ?? true)) {
+    return false;
+  }
+  if (!(filter.kinds?.includes(ev.kind) ?? true)) {
+    return false;
+  }
+  const orTags = Object.entries(filter).filter(([k]) => k.startsWith("#"));
+  for (const [k, v] of orTags) {
+    const vargs = v;
+    for (const x of vargs) {
+      if (!ev.tags.find((a) => a[0] === k.slice(1) && a[1] === x)) {
+        return false;
+      }
+    }
+  }
+  const andTags = Object.entries(filter).filter(([k]) => k.startsWith("&"));
+  for (const [k, v] of andTags) {
+    const vargs = v;
+    const allMatch = vargs.every((x) => ev.tags.some((tag) => tag[0] === k.slice(1) && tag[1] === x));
+    if (!allMatch) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/abstract.ts
+var AbstractMemoryRelay = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+    this._events = /* @__PURE__ */ new Map();
+    this._nip11s = /* @__PURE__ */ new Map();
+    this.highestTimestamp = new Array(0);
+    this.lowestTimestamp = new Array(0);
+    this.debounceMS = 1e3;
+  }
+  set events(e) {
+    this._events = e;
+  }
+  get events() {
+    return this._events;
+  }
+  get nip11s() {
+    return this._nip11s;
+  }
+  on(event, listener) {
+    this.listeners.set(event, listener);
+  }
+  off(event) {
+    this.listeners.delete(event);
+  }
+  instantiateEvent(event, key) {
+    return this.listeners.get("instantiate")?.(event, key, this) ?? event;
+  }
+  qualifyEvent(event, key) {
+    return this.listeners.get("qualify")?.(event, key, this) ?? true;
+  }
+  exists(note) {
+    return typeof note === "string" ? this.idExists(note) : this.noteExists(note);
+  }
+  noteExists(note) {
+    return this.events.has(eventKey(note));
+  }
+  idExists(id) {
+    return this.events.has(id);
+  }
+  count(filters) {
+    let ret = 0;
+    for (const [, e] of this.events) {
+      for (const filter of filters) {
+        if (eventMatchesFilter(e, filter)) {
+          ret++;
+        }
+      }
+    }
+    return ret;
+  }
+  summary() {
+    const ret = {};
+    for (const [, event] of this.events) {
+      if (!event.kind) continue;
+      ret[event.kind.toString()] ??= 0;
+      ret[event.kind.toString()]++;
+    }
+    return ret;
+  }
+  async dump() {
+    const enc = new TextEncoder();
+    return enc.encode(JSON.stringify(Array.from(this.events.values())));
+  }
+  close() {
+  }
+  async wipe() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  maybeInsert(event) {
+    if (!this.shouldInsert(event)) return 0;
+    const key = eventKey(event);
+    this.events.set(key, this.instantiateEvent(event, key));
+    return 1;
+  }
+  event(ev) {
+    return this.maybeInsert(ev) ? true : false;
+  }
+  eventBatch(evs) {
+    const inserted = [];
+    for (const ev of evs) {
+      if (ev.tags?.find((tag) => tag[1] === "tor")) {
+        console.log("TOR RELAY", ev.id);
+      }
+      const inserts = this.maybeInsert(ev);
+      if (!inserts) continue;
+      inserted.push(ev);
+    }
+    return inserted.length;
+  }
+  setTimestampRange(event, index = 0) {
+    const ts = event.created_at;
+    if (!this.highestTimestamp?.[index] || ts > this.highestTimestamp[index]) this.highestTimestamp[index] = ts;
+    if (!this.lowestTimestamp?.[index] || ts < this.lowestTimestamp[index]) this.lowestTimestamp[index] = ts;
+  }
+  formatCollection(collection) {
+    return collection;
+  }
+  req(id, filters, format = true) {
+    const ret = [];
+    for (const [, e] of this.events) {
+      for (const [index, filter] of filters.entries()) {
+        if (eventMatchesFilter(e, filter)) {
+          ret.push(e);
+          this.setTimestampRange(e, index);
+        }
+      }
+    }
+    return format ? this.formatCollection(ret) : ret;
+  }
+  get(key) {
+    return this.events.get(key);
+  }
+  delete(filters) {
+    const forDelete = this.req("ids-for-delete", filters, false);
+    const keys = forDelete.map((e) => eventKey(e)).filter((a) => typeof a === "string");
+    if (!keys?.length) return [];
+    return this._delete(keys);
+  }
+  _delete(keys) {
+    keys.forEach((k) => this.events.delete(k));
+    return keys;
+  }
+  destroy() {
+    this.wipe();
+  }
+  shouldInsert(event) {
+    const { type, key } = eventIdData(event);
+    const existing = this.events.get(key);
+    const qualified = this.qualifyEvent(event, key);
+    if (!qualified) return false;
+    if (!existing) return true;
+    if (type === "replaceable" || type === "parameterized") {
+      return event.created_at > existing.created_at;
+    }
+    return true;
+  }
+};
+
+export {
+  eventType,
+  eventAddr,
+  eventKey,
+  eventIdData,
+  eventMatchesFilter,
+  AbstractMemoryRelay
+};
+//# sourceMappingURL=chunk-QC3J2K4S.mjs.map

package/dist/esm/chunk-QC3J2K4S.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils.ts", "../../src/abstract.ts"],
+  "sourcesContent": ["import { isParameterizedReplaceableKind, isReplaceableKind } from \"nostr-tools/kinds\";\nimport { EventKeyDataType, EventType } from \"./types.js\";\nimport { Filter, NostrEvent } from \"nostr-tools\";\nimport { IEvent } from \"@nostrwatch/route66/models/Event\";\n\nexport const eventType = ( event: any ): EventType => {\n    if(isReplaceableKind(event.kind)) {\n        return 'replaceable';\n    }\n    else if(isParameterizedReplaceableKind(event.kind)){\n        return 'parameterized';\n    }\n    else {\n        return 'event'\n    }\n}\n\nexport const eventAddr = ( event: any, type?: EventType ) => {\n    let { pubkey, kind } = event;\n    type = type ?? eventType(event);\n    pubkey = pubkey.slice(0,16);\n    if(type === 'parameterized') {\n        const dtag = event.tags.find((t: string[]) => t[0] === 'd')?.[1]\n        const key = `${pubkey}:${kind}:${dtag}`;\n        return key;\n    }\n    else if(type === 'replaceable') {\n        const key = `${pubkey}:${kind}`\n        return key;\n    }\n}\n\nexport const eventKey = (event: any, type?: EventType) =>{\n    type = type ?? eventType(event);\n    if(type === 'replaceable') {\n        return eventAddr(event, type);\n    }\n    else if(type === 'parameterized') {\n        return eventAddr(event, type);\n    }\n    else {\n        return event.id\n    }\n}\n\nexport const eventIdData = (event: any): EventKeyDataType => {\n    const type =  eventType(event)\n    return {\n        type,\n        key: eventKey(event, type)\n    }\n}\n\nexport function eventMatchesFilter(ev: IEvent | NostrEvent | any, filter: Filter): boolean {\n    if (filter.since && ev.created_at < filter.since) {\n      return false;\n    }\n    if (filter.until && ev.created_at > filter.until) {\n      return false;\n    }\n    if (!(filter.ids?.includes(ev.id) ?? true)) {\n      return false;\n    }\n    if (!(filter.authors?.includes(ev.pubkey) ?? true)) {\n      return false;\n    }\n    if (!(filter.kinds?.includes(ev.kind) ?? true)) {\n      return false;\n    }\n    const orTags = Object.entries(filter).filter(([k]) => k.startsWith(\"#\"));\n    for (const [k, v] of orTags) {\n      const vargs = v as Array<string>;\n      for (const x of vargs) {\n        if (!ev.tags.find((a: string[]) => a[0] === k.slice(1) && a[1] === x)) {\n          return false;\n        }\n      }\n    }\n    const andTags = Object.entries(filter).filter(([k]) => k.startsWith(\"&\"));\n    for (const [k, v] of andTags) {\n      const vargs = v as Array<string>;\n      const allMatch = vargs.every(x => ev.tags.some((tag: string[]) => tag[0] === k.slice(1) && tag[1] === x));\n      if (!allMatch) {\n        return false;\n      }\n    }\n    return true;\n  }", "// abstract.ts\n\nimport { Filter } from \"nostr-tools\";\nimport { eventIdData, eventKey, eventMatchesFilter } from \"./utils.js\";\nimport { AbstractMemoryRelayCallback, AbstractMemoryRelayCallbackInstatiate, AbstractMemoryRelayCallbackQualify } from \"./types.js\";\nimport { BaseEvent } from \"./types.js\";\n\nexport abstract class AbstractMemoryRelay<\n  Input extends BaseEvent = any,\n  Output extends BaseEvent = any,\n  OutputSingle = Output,\n  OutputCollection = any | any[],\n  OutputCount = any\n> {\n  private listeners: Map<string, AbstractMemoryRelayCallback<this, Output>> = new Map();\n\n  protected _events: Map<string, Output> = new Map();  \n  protected _nip11s: Map<string, any> = new Map();\n\n  highestTimestamp: number[] = new Array(0);\n  lowestTimestamp: number[] = new Array(0);\n  debounceMS: number = 1000;\n\n  protected set events(e: Map<string, Output>) {\n    this._events = e;\n  }\n\n  get events() {\n    return this._events;\n  }\n\n  get nip11s() {\n    return this._nip11s;\n  }\n\n  abstract init(): Promise<void>;\n\n  on(event: \"qualify\" | \"instantiate\", listener: AbstractMemoryRelayCallback<this, Output>): void {\n    this.listeners.set(event, listener);\n  }\n\n  off(event: \"qualify\" | \"instantiate\"): void {\n    this.listeners.delete(event);\n  }\n\n  protected instantiateEvent(event: Input, key: string): Output {\n    return (\n      (this.listeners.get(\"instantiate\") as AbstractMemoryRelayCallbackInstatiate<this, Output>)?.(event, key, this)\n      ?? (event as unknown as Output)\n    );\n  }\n\n  protected qualifyEvent(event: Input, key: string): boolean {\n    return (\n      (this.listeners.get(\"qualify\") as AbstractMemoryRelayCallbackQualify<this>)?.(event, key, this)\n      ?? true\n    );\n  }\n\n  exists(note: Input | string): boolean {\n    return typeof note === \"string\" ? this.idExists(note) : this.noteExists(note);\n  }\n\n  noteExists(note: Input): boolean {\n    return this.events.has(eventKey(note));\n  }\n\n  idExists(id: string): boolean {\n    return this.events.has(id);\n  }\n\n  count(filters: Filter[]): OutputCount {\n    let ret = 0;\n    for (const [, e] of this.events) {\n      for (const filter of filters) {\n        if (eventMatchesFilter(e, filter)) {\n          ret++;\n        }\n      }\n    }\n    return ret as unknown as OutputCount;\n  }\n\n  summary(): Record<string, number> {\n    const ret: Record<string, number> = {};\n    for (const [, event] of this.events) {\n      if (!event.kind) continue;\n      ret[event.kind.toString()] ??= 0;\n      ret[event.kind.toString()]++;\n    }\n    return ret;\n  }\n\n  async dump(): Promise<Uint8Array> {\n    const enc = new TextEncoder();\n    return enc.encode(JSON.stringify(Array.from(this.events.values())));\n  }\n\n  close(): void {\n    // no-op\n  }\n\n  async wipe() {\n    this.events = new Map();\n  }\n\n  maybeInsert(event: Input): number {\n    if (!this.shouldInsert(event)) return 0;\n    const key = eventKey(event);\n    this.events.set(key, this.instantiateEvent(event, key));\n    return 1;\n  }\n\n  event(ev: Input): boolean {\n    return this.maybeInsert(ev) ? true : false;\n  }\n\n  eventBatch(evs: Input[]): number {\n    const inserted = [];\n    for (const ev of evs) {\n      if(ev.tags?.find(tag => tag[1] === \"tor\")){\n        console.log('TOR RELAY', ev.id)\n      }\n      const inserts: number = this.maybeInsert(ev);\n      if (!inserts) continue;\n      inserted.push(ev);\n    }\n    return inserted.length;\n  }\n\n  setTimestampRange(event: Input | Output | BaseEvent, index: number = 0) {\n    const ts = event.created_at as number;\n    if (!this.highestTimestamp?.[index] || ts > this.highestTimestamp[index]) this.highestTimestamp[index] = ts;\n    if (!this.lowestTimestamp?.[index] || ts < this.lowestTimestamp[index]) this.lowestTimestamp[index] = ts;\n  }\n\n  formatCollection(collection: Output[]): OutputCollection {\n    return collection as unknown as OutputCollection;\n  }\n\n  req(id: string, filters: Filter[], format: boolean = true): OutputCollection | Output[] {\n    const ret: Output[] = [];\n    for (const [, e] of this.events) {\n      for (const [index, filter] of filters.entries()) {\n        if (eventMatchesFilter(e, filter)) {\n          ret.push(e);\n          this.setTimestampRange(e, index);\n        }\n      }\n    }\n    return format ? this.formatCollection(ret) : ret;\n  }\n\n  get(key: string): Output | undefined {\n    return this.events.get(key) as Output | undefined;\n  }\n\n  delete(filters: Filter[]): string[] {\n    const forDelete: Output[] = this.req(\"ids-for-delete\", filters, false) as Output[];\n    const keys = forDelete\n      .map((e) => eventKey(e))\n      .filter((a) => typeof a === \"string\");\n    if (!keys?.length) return [];\n    return this._delete(keys);\n  }\n\n  _delete(keys: string[]): string[] {\n    keys.forEach((k) => this.events.delete(k));\n    return keys;\n  }\n\n  destroy() {\n    this.wipe();\n  }\n\n  protected shouldInsert(event: Input) {\n    const { type, key } = eventIdData(event);\n    const existing = this.events.get(key);\n    const qualified = this.qualifyEvent(event, key)\n    if (!qualified) return false;\n    if (!existing) return true;\n    if (type === \"replaceable\" || type === \"parameterized\") {\n      return (event.created_at as number) > (existing.created_at as number)\n    }\n    return true;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/esm/chunk-WJKCFUCB.mjs

@@ -0,0 +1,104 @@
+import {
+  AbstractMemoryRelay,
+  eventKey,
+  eventMatchesFilter
+} from "./chunk-QC3J2K4S.mjs";
+
+// src/svelte.ts
+import { derived, get } from "svelte/store";
+var SvelteMemoryRelay = class extends AbstractMemoryRelay {
+  constructor(_store) {
+    super();
+    this._store = _store;
+  }
+  get events() {
+    return get(this._store);
+  }
+  get store() {
+    return this._store;
+  }
+  set events(e) {
+    this.store.set(e);
+  }
+  async init() {
+    return Promise.resolve();
+  }
+  maybeInsert(payload) {
+    let added = 0;
+    this._store.update((current) => {
+      let newMap;
+      if (Array.isArray(payload)) {
+        newMap = new Map(current);
+        for (const ev of payload) {
+          if (!this.shouldInsert(ev)) continue;
+          const key = eventKey(ev);
+          newMap.set(key, this.instantiateEvent(ev, key));
+          added++;
+        }
+      } else {
+        if (this.shouldInsert(payload)) {
+          const key = eventKey(payload);
+          current.set(key, this.instantiateEvent(payload, key));
+          added++;
+        }
+      }
+      return newMap ? newMap : current;
+    });
+    return added;
+  }
+  $req(id, filters, format = true) {
+    const store = derived(
+      this.store,
+      ($events) => {
+        const results = [];
+        for (const [index, filter] of filters.entries()) {
+          for (const [key, event] of $events) {
+            if (eventMatchesFilter(event, filter)) {
+              results.push(event);
+            }
+          }
+        }
+        return results;
+      }
+    );
+    return store;
+  }
+  $get(key) {
+    return derived(this.store, ($events) => {
+      return $events.get(key);
+    });
+  }
+  $count(filters) {
+    const request = this.req("", filters);
+    const result = derived(request, ($events) => {
+      return $events.length;
+    });
+    return result;
+  }
+  _delete(keys) {
+    const deleted = /* @__PURE__ */ new Set();
+    this.store.update((current) => {
+      for (const key of keys) {
+        if (!current.has(key)) continue;
+        deleted.add(current.get(key)?.id || key);
+        current.delete(key);
+      }
+      return current;
+    });
+    return Array.from(deleted);
+  }
+  event(ev) {
+    return this.maybeInsert(ev) ? true : false;
+  }
+  eventBatch(evs) {
+    return this.maybeInsert(evs);
+  }
+  async wipe() {
+    this.store.set(/* @__PURE__ */ new Map());
+  }
+};
+
+export {
+  SvelteMemoryRelay
+};
+//# sourceMappingURL=chunk-WJKCFUCB.mjs.map

package/dist/esm/chunk-WJKCFUCB.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/svelte.ts"],
+  "sourcesContent": ["// svelte.ts\n\nimport { derived, get, type Readable, type Writable } from \"svelte/store\";\nimport { Filter } from \"nostr-tools\";\nimport { eventKey, eventMatchesFilter } from \"./utils.js\";\nimport { AbstractMemoryRelay } from \"./abstract.js\";\nimport { BaseEvent } from \"./types.js\";\n\nexport class SvelteMemoryRelay<\n  InputEvent extends BaseEvent,\n  OutputEvent extends BaseEvent,\n  OutputSingle extends Readable<OutputEvent> = Readable<OutputEvent>,\n  OutputCollection extends Readable<OutputEvent[]> = Readable<OutputEvent[]>,\n  OutputCount extends Readable<number> = Readable<number>\n> extends AbstractMemoryRelay<InputEvent, OutputEvent, OutputSingle, OutputCollection, OutputCount> {\n\n  constructor(private _store: Writable<Map<string, OutputEvent>>) {\n    super();\n  }\n\n  get events(): Map<string, OutputEvent> {\n    return get(this._store);\n  }\n\n  get store(): Writable<Map<string, OutputEvent>> {\n    return this._store;\n  }\n\n  protected set events(e: Map<string, OutputEvent>) {\n    this.store.set(e);\n  }\n\n  async init(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  maybeInsert(payload: InputEvent | InputEvent[]): number {\n    let added = 0;\n    this._store.update((current) => {\n      let newMap: Map<string, OutputEvent> | undefined;\n      if (Array.isArray(payload)) {\n        newMap = new Map(current);\n        for (const ev of payload) {\n          if (!this.shouldInsert(ev)) continue;\n          const key = eventKey(ev);\n          newMap.set(key, this.instantiateEvent(ev, key));\n          added++;\n        }\n      } else {\n        if (this.shouldInsert(payload)) {\n          const key = eventKey(payload);\n          current.set(key, this.instantiateEvent(payload, key));\n          added++;\n        }\n      }\n      return newMap? newMap: current;\n    });\n    return added;\n  }\n\n  $req(id: string, filters: Filter[], format: boolean = true): OutputCollection {\n    const store = derived<Writable<Map<string, OutputEvent>>, OutputEvent[]>(\n      this.store, \n      ($events) => {\n        const results: OutputEvent[] = [];\n        for (const [index, filter] of filters.entries()) {\n          for (const [key, event] of $events) {\n            if (eventMatchesFilter(event, filter)) {\n              results.push(event);\n              // this.setTimestampRange(event, index);\n            }\n          }\n        }\n        return results;\n      }\n    );\n    return store as OutputCollection;\n  }\n\n  $get(key: string): OutputSingle | undefined {\n    return derived(this.store, ($events) => {\n      return $events.get(key);\n    }) as OutputSingle | undefined;\n  }\n\n  $count(filters: Filter[]): OutputCount {\n    const request = this.req(\"\", filters) as Readable<OutputEvent[]>;\n    const result = derived<Readable<OutputEvent[]>, number>(request, ($events) => {\n      return $events.length;\n    });\n    return result as OutputCount;\n  }\n\n  _delete(keys: string[]): string[] {\n    const deleted = new Set<string>();\n    this.store.update((current) => {\n      for (const key of keys) {\n        if(!current.has(key)) continue;\n        deleted.add(current.get(key)?.id || key);\n        current.delete(key);\n      }\n      return current;\n    });\n    return Array.from(deleted);\n  }\n\n  event(ev: InputEvent): boolean {\n    return this.maybeInsert(ev) ? true : false;\n  }\n\n  eventBatch(evs: InputEvent[]): number {\n    return this.maybeInsert(evs);\n  }\n\n  async wipe(): Promise<void> {\n    this.store.set(new Map<string, OutputEvent>());\n  }\n}\n"],
+  "mappings": ";;;;;;;AAEA,SAAS,SAAS,WAAyC;AAMpD,IAAM,oBAAN,cAMG,oBAA0F;AAAA,EAElG,YAAoB,QAA4C;AAC9D,UAAM;AADY;AAAA,EAEpB;AAAA,EAEA,IAAI,SAAmC;AACrC,WAAO,IAAI,KAAK,MAAM;AAAA,EACxB;AAAA,EAEA,IAAI,QAA4C;AAC9C,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAc,OAAO,GAA6B;AAChD,SAAK,MAAM,IAAI,CAAC;AAAA,EAClB;AAAA,EAEA,MAAM,OAAsB;AAC1B,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAAA,EAEA,YAAY,SAA4C;AACtD,QAAI,QAAQ;AACZ,SAAK,OAAO,OAAO,CAAC,YAAY;AAC9B,UAAI;AACJ,UAAI,MAAM,QAAQ,OAAO,GAAG;AAC1B,iBAAS,IAAI,IAAI,OAAO;AACxB,mBAAW,MAAM,SAAS;AACxB,cAAI,CAAC,KAAK,aAAa,EAAE,EAAG;AAC5B,gBAAM,MAAM,SAAS,EAAE;AACvB,iBAAO,IAAI,KAAK,KAAK,iBAAiB,IAAI,GAAG,CAAC;AAC9C;AAAA,QACF;AAAA,MACF,OAAO;AACL,YAAI,KAAK,aAAa,OAAO,GAAG;AAC9B,gBAAM,MAAM,SAAS,OAAO;AAC5B,kBAAQ,IAAI,KAAK,KAAK,iBAAiB,SAAS,GAAG,CAAC;AACpD;AAAA,QACF;AAAA,MACF;AACA,aAAO,SAAQ,SAAQ;AAAA,IACzB,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEA,KAAK,IAAY,SAAmB,SAAkB,MAAwB;AAC5E,UAAM,QAAQ;AAAA,MACZ,KAAK;AAAA,MACL,CAAC,YAAY;AACX,cAAM,UAAyB,CAAC;AAChC,mBAAW,CAAC,OAAO,MAAM,KAAK,QAAQ,QAAQ,GAAG;AAC/C,qBAAW,CAAC,KAAK,KAAK,KAAK,SAAS;AAClC,gBAAI,mBAAmB,OAAO,MAAM,GAAG;AACrC,sBAAQ,KAAK,KAAK;AAAA,YAEpB;AAAA,UACF;AAAA,QACF;AACA,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAAA,EAEA,KAAK,KAAuC;AAC1C,WAAO,QAAQ,KAAK,OAAO,CAAC,YAAY;AACtC,aAAO,QAAQ,IAAI,GAAG;AAAA,IACxB,CAAC;AAAA,EACH;AAAA,EAEA,OAAO,SAAgC;AACrC,UAAM,UAAU,KAAK,IAAI,IAAI,OAAO;AACpC,UAAM,SAAS,QAAyC,SAAS,CAAC,YAAY;AAC5E,aAAO,QAAQ;AAAA,IACjB,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EAEA,QAAQ,MAA0B;AAChC,UAAM,UAAU,oBAAI,IAAY;AAChC,SAAK,MAAM,OAAO,CAAC,YAAY;AAC7B,iBAAW,OAAO,MAAM;AACtB,YAAG,CAAC,QAAQ,IAAI,GAAG,EAAG;AACtB,gBAAQ,IAAI,QAAQ,IAAI,GAAG,GAAG,MAAM,GAAG;AACvC,gBAAQ,OAAO,GAAG;AAAA,MACpB;AACA,aAAO;AAAA,IACT,CAAC;AACD,WAAO,MAAM,KAAK,OAAO;AAAA,EAC3B;AAAA,EAEA,MAAM,IAAyB;AAC7B,WAAO,KAAK,YAAY,EAAE,IAAI,OAAO;AAAA,EACvC;AAAA,EAEA,WAAW,KAA2B;AACpC,WAAO,KAAK,YAAY,GAAG;AAAA,EAC7B;AAAA,EAEA,MAAM,OAAsB;AAC1B,SAAK,MAAM,IAAI,oBAAI,IAAyB,CAAC;AAAA,EAC/C;AACF;",
+  "names": []
+}

package/dist/esm/index.mjs

@@ -0,0 +1,21 @@
+import {
+  SvelteMemoryRelay
+} from "./chunk-WJKCFUCB.mjs";
+import {
+  AbstractMemoryRelay,
+  eventAddr,
+  eventIdData,
+  eventKey,
+  eventMatchesFilter,
+  eventType
+} from "./chunk-QC3J2K4S.mjs";
+export {
+  AbstractMemoryRelay,
+  SvelteMemoryRelay,
+  eventAddr,
+  eventIdData,
+  eventKey,
+  eventMatchesFilter,
+  eventType
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/esm/svelte.mjs

@@ -0,0 +1,8 @@
+import {
+  SvelteMemoryRelay
+} from "./chunk-WJKCFUCB.mjs";
+import "./chunk-QC3J2K4S.mjs";
+export {
+  SvelteMemoryRelay
+};
+//# sourceMappingURL=svelte.mjs.map

package/dist/esm/svelte.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './abstract.js';
+export * from './svelte.js';
+export * from './utils.js';
+export * from './types.js';

package/dist/svelte.d.ts

@@ -0,0 +1,20 @@
+import { type Readable, type Writable } from "svelte/store";
+import { Filter } from "nostr-tools";
+import { AbstractMemoryRelay } from "./abstract.js";
+import { BaseEvent } from "./types.js";
+export declare class SvelteMemoryRelay<InputEvent extends BaseEvent, OutputEvent extends BaseEvent, OutputSingle extends Readable<OutputEvent> = Readable<OutputEvent>, OutputCollection extends Readable<OutputEvent[]> = Readable<OutputEvent[]>, OutputCount extends Readable<number> = Readable<number>> extends AbstractMemoryRelay<InputEvent, OutputEvent, OutputSingle, OutputCollection, OutputCount> {
+    private _store;
+    constructor(_store: Writable<Map<string, OutputEvent>>);
+    get events(): Map<string, OutputEvent>;
+    get store(): Writable<Map<string, OutputEvent>>;
+    protected set events(e: Map<string, OutputEvent>);
+    init(): Promise<void>;
+    maybeInsert(payload: InputEvent | InputEvent[]): number;
+    $req(id: string, filters: Filter[], format?: boolean): OutputCollection;
+    $get(key: string): OutputSingle | undefined;
+    $count(filters: Filter[]): OutputCount;
+    _delete(keys: string[]): string[];
+    event(ev: InputEvent): boolean;
+    eventBatch(evs: InputEvent[]): number;
+    wipe(): Promise<void>;
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+export type EventType = 'replaceable' | 'parameterized' | 'event';
+export interface BaseEvent {
+    id?: string | null;
+    created_at?: number | null;
+    kind: number | null;
+    pubkey: string | null;
+    tags: string[][] | null;
+    content: string | null;
+    sig?: string | null;
+}
+export type EventKeyDataType = {
+    type: EventType;
+    key: string;
+};
+export type AbstractMemoryRelayCallbackQualify<I> = (event: any, key: string, instance: I) => boolean;
+export type AbstractMemoryRelayCallbackInstatiate<I, Output> = (event: any, key: string, instance: I) => Output;
+export type AbstractMemoryRelayCallback<I, Output> = AbstractMemoryRelayCallbackQualify<I> | AbstractMemoryRelayCallbackInstatiate<I, Output>;

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import { EventKeyDataType, EventType } from "./types.js";
+import { Filter, NostrEvent } from "nostr-tools";
+import { IEvent } from "@nostrwatch/route66/models/Event";
+export declare const eventType: (event: any) => EventType;
+export declare const eventAddr: (event: any, type?: EventType) => string | undefined;
+export declare const eventKey: (event: any, type?: EventType) => any;
+export declare const eventIdData: (event: any) => EventKeyDataType;
+export declare function eventMatchesFilter(ev: IEvent | NostrEvent | any, filter: Filter): boolean;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@nostrwatch/memory-relay",
+  "version": "1.3.0",
+  "description": "A simple memory relay",
+  "type": "module",
+  "main": "dist/esm/index.mjs",
+  "types": "dist/index.d.ts",
+  "module": "src/index.ts",
+  "repository": "https://github.com/sandwichfarm/nostr-watch",
+  "author": "Sandwich",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/esm/index.js"
+    },
+    "./abstract": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/abstract.mjs",
+      "require": "./dist/esm/abstract.js"
+    },
+    "./svelte": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/abstract.mjs",
+      "require": "./dist/esm/abstract.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "dependencies": {
+    "lodash": "^4.17.23"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "nostr-tools": "^2.10.4",
+    "svelte": "^5.2.7",
+    "tseep": "^1.3.1",
+    "@nostrwatch/route66": "^0.0.1",
+    "@nostrwatch/utils": "^0.1.9"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "tsc": "tsc",
+    "build": "pnpm clean && pnpm tsc && pnpm node build.js",
+    "build:esm": "esbuild src/index.ts src/abstract.ts src/svelte.ts --bundle --minify --sourcemap --outdir=dist/esm --format=esm --out-extension:.js=.mjs"
+  }
+}

package/src/abstract.ts

@@ -0,0 +1,187 @@
+// abstract.ts
+
+import { Filter } from "nostr-tools";
+import { eventIdData, eventKey, eventMatchesFilter } from "./utils.js";
+import { AbstractMemoryRelayCallback, AbstractMemoryRelayCallbackInstatiate, AbstractMemoryRelayCallbackQualify } from "./types.js";
+import { BaseEvent } from "./types.js";
+
+export abstract class AbstractMemoryRelay<
+  Input extends BaseEvent = any,
+  Output extends BaseEvent = any,
+  OutputSingle = Output,
+  OutputCollection = any | any[],
+  OutputCount = any
+> {
+  private listeners: Map<string, AbstractMemoryRelayCallback<this, Output>> = new Map();
+
+  protected _events: Map<string, Output> = new Map();  
+  protected _nip11s: Map<string, any> = new Map();
+
+  highestTimestamp: number[] = new Array(0);
+  lowestTimestamp: number[] = new Array(0);
+  debounceMS: number = 1000;
+
+  protected set events(e: Map<string, Output>) {
+    this._events = e;
+  }
+
+  get events() {
+    return this._events;
+  }
+
+  get nip11s() {
+    return this._nip11s;
+  }
+
+  abstract init(): Promise<void>;
+
+  on(event: "qualify" | "instantiate", listener: AbstractMemoryRelayCallback<this, Output>): void {
+    this.listeners.set(event, listener);
+  }
+
+  off(event: "qualify" | "instantiate"): void {
+    this.listeners.delete(event);
+  }
+
+  protected instantiateEvent(event: Input, key: string): Output {
+    return (
+      (this.listeners.get("instantiate") as AbstractMemoryRelayCallbackInstatiate<this, Output>)?.(event, key, this)
+      ?? (event as unknown as Output)
+    );
+  }
+
+  protected qualifyEvent(event: Input, key: string): boolean {
+    return (
+      (this.listeners.get("qualify") as AbstractMemoryRelayCallbackQualify<this>)?.(event, key, this)
+      ?? true
+    );
+  }
+
+  exists(note: Input | string): boolean {
+    return typeof note === "string" ? this.idExists(note) : this.noteExists(note);
+  }
+
+  noteExists(note: Input): boolean {
+    return this.events.has(eventKey(note));
+  }
+
+  idExists(id: string): boolean {
+    return this.events.has(id);
+  }
+
+  count(filters: Filter[]): OutputCount {
+    let ret = 0;
+    for (const [, e] of this.events) {
+      for (const filter of filters) {
+        if (eventMatchesFilter(e, filter)) {
+          ret++;
+        }
+      }
+    }
+    return ret as unknown as OutputCount;
+  }
+
+  summary(): Record<string, number> {
+    const ret: Record<string, number> = {};
+    for (const [, event] of this.events) {
+      if (!event.kind) continue;
+      ret[event.kind.toString()] ??= 0;
+      ret[event.kind.toString()]++;
+    }
+    return ret;
+  }
+
+  async dump(): Promise<Uint8Array> {
+    const enc = new TextEncoder();
+    return enc.encode(JSON.stringify(Array.from(this.events.values())));
+  }
+
+  close(): void {
+    // no-op
+  }
+
+  async wipe() {
+    this.events = new Map();
+  }
+
+  maybeInsert(event: Input): number {
+    if (!this.shouldInsert(event)) return 0;
+    const key = eventKey(event);
+    this.events.set(key, this.instantiateEvent(event, key));
+    return 1;
+  }
+
+  event(ev: Input): boolean {
+    return this.maybeInsert(ev) ? true : false;
+  }
+
+  eventBatch(evs: Input[]): number {
+    const inserted = [];
+    for (const ev of evs) {
+      if(ev.tags?.find(tag => tag[1] === "tor")){
+        console.log('TOR RELAY', ev.id)
+      }
+      const inserts: number = this.maybeInsert(ev);
+      if (!inserts) continue;
+      inserted.push(ev);
+    }
+    return inserted.length;
+  }
+
+  setTimestampRange(event: Input | Output | BaseEvent, index: number = 0) {
+    const ts = event.created_at as number;
+    if (!this.highestTimestamp?.[index] || ts > this.highestTimestamp[index]) this.highestTimestamp[index] = ts;
+    if (!this.lowestTimestamp?.[index] || ts < this.lowestTimestamp[index]) this.lowestTimestamp[index] = ts;
+  }
+
+  formatCollection(collection: Output[]): OutputCollection {
+    return collection as unknown as OutputCollection;
+  }
+
+  req(id: string, filters: Filter[], format: boolean = true): OutputCollection | Output[] {
+    const ret: Output[] = [];
+    for (const [, e] of this.events) {
+      for (const [index, filter] of filters.entries()) {
+        if (eventMatchesFilter(e, filter)) {
+          ret.push(e);
+          this.setTimestampRange(e, index);
+        }
+      }
+    }
+    return format ? this.formatCollection(ret) : ret;
+  }
+
+  get(key: string): Output | undefined {
+    return this.events.get(key) as Output | undefined;
+  }
+
+  delete(filters: Filter[]): string[] {
+    const forDelete: Output[] = this.req("ids-for-delete", filters, false) as Output[];
+    const keys = forDelete
+      .map((e) => eventKey(e))
+      .filter((a) => typeof a === "string");
+    if (!keys?.length) return [];
+    return this._delete(keys);
+  }
+
+  _delete(keys: string[]): string[] {
+    keys.forEach((k) => this.events.delete(k));
+    return keys;
+  }
+
+  destroy() {
+    this.wipe();
+  }
+
+  protected shouldInsert(event: Input) {
+    const { type, key } = eventIdData(event);
+    const existing = this.events.get(key);
+    const qualified = this.qualifyEvent(event, key)
+    if (!qualified) return false;
+    if (!existing) return true;
+    if (type === "replaceable" || type === "parameterized") {
+      return (event.created_at as number) > (existing.created_at as number)
+    }
+    return true;
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './abstract.js';
+export * from './svelte.js';
+export * from './utils.js';
+export * from './types.js';

package/src/svelte.ts

@@ -0,0 +1,118 @@
+// svelte.ts
+
+import { derived, get, type Readable, type Writable } from "svelte/store";
+import { Filter } from "nostr-tools";
+import { eventKey, eventMatchesFilter } from "./utils.js";
+import { AbstractMemoryRelay } from "./abstract.js";
+import { BaseEvent } from "./types.js";
+
+export class SvelteMemoryRelay<
+  InputEvent extends BaseEvent,
+  OutputEvent extends BaseEvent,
+  OutputSingle extends Readable<OutputEvent> = Readable<OutputEvent>,
+  OutputCollection extends Readable<OutputEvent[]> = Readable<OutputEvent[]>,
+  OutputCount extends Readable<number> = Readable<number>
+> extends AbstractMemoryRelay<InputEvent, OutputEvent, OutputSingle, OutputCollection, OutputCount> {
+
+  constructor(private _store: Writable<Map<string, OutputEvent>>) {
+    super();
+  }
+
+  get events(): Map<string, OutputEvent> {
+    return get(this._store);
+  }
+
+  get store(): Writable<Map<string, OutputEvent>> {
+    return this._store;
+  }
+
+  protected set events(e: Map<string, OutputEvent>) {
+    this.store.set(e);
+  }
+
+  async init(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  maybeInsert(payload: InputEvent | InputEvent[]): number {
+    let added = 0;
+    this._store.update((current) => {
+      let newMap: Map<string, OutputEvent> | undefined;
+      if (Array.isArray(payload)) {
+        newMap = new Map(current);
+        for (const ev of payload) {
+          if (!this.shouldInsert(ev)) continue;
+          const key = eventKey(ev);
+          newMap.set(key, this.instantiateEvent(ev, key));
+          added++;
+        }
+      } else {
+        if (this.shouldInsert(payload)) {
+          const key = eventKey(payload);
+          current.set(key, this.instantiateEvent(payload, key));
+          added++;
+        }
+      }
+      return newMap? newMap: current;
+    });
+    return added;
+  }
+
+  $req(id: string, filters: Filter[], format: boolean = true): OutputCollection {
+    const store = derived<Writable<Map<string, OutputEvent>>, OutputEvent[]>(
+      this.store, 
+      ($events) => {
+        const results: OutputEvent[] = [];
+        for (const [index, filter] of filters.entries()) {
+          for (const [key, event] of $events) {
+            if (eventMatchesFilter(event, filter)) {
+              results.push(event);
+              // this.setTimestampRange(event, index);
+            }
+          }
+        }
+        return results;
+      }
+    );
+    return store as OutputCollection;
+  }
+
+  $get(key: string): OutputSingle | undefined {
+    return derived(this.store, ($events) => {
+      return $events.get(key);
+    }) as OutputSingle | undefined;
+  }
+
+  $count(filters: Filter[]): OutputCount {
+    const request = this.req("", filters) as Readable<OutputEvent[]>;
+    const result = derived<Readable<OutputEvent[]>, number>(request, ($events) => {
+      return $events.length;
+    });
+    return result as OutputCount;
+  }
+
+  _delete(keys: string[]): string[] {
+    const deleted = new Set<string>();
+    this.store.update((current) => {
+      for (const key of keys) {
+        if(!current.has(key)) continue;
+        deleted.add(current.get(key)?.id || key);
+        current.delete(key);
+      }
+      return current;
+    });
+    return Array.from(deleted);
+  }
+
+  event(ev: InputEvent): boolean {
+    return this.maybeInsert(ev) ? true : false;
+  }
+
+  eventBatch(evs: InputEvent[]): number {
+    return this.maybeInsert(evs);
+  }
+
+  async wipe(): Promise<void> {
+    this.store.set(new Map<string, OutputEvent>());
+  }
+}

package/src/types.ts

@@ -0,0 +1,23 @@
+import type { Listener } from "tseep";
+
+export type EventType = 'replaceable' | 'parameterized' | 'event';
+
+export interface BaseEvent {
+  id?: string | null;
+  created_at?: number | null;
+  kind: number | null;
+  pubkey: string | null;
+  tags: string[][] | null;
+  content: string | null;
+  sig?: string | null;
+}
+
+export type EventKeyDataType = {
+    type: EventType;
+    key: string;
+}
+
+export type AbstractMemoryRelayCallbackQualify<I> = (event: any, key: string, instance: I) => boolean;
+export type AbstractMemoryRelayCallbackInstatiate<I, Output> = (event: any, key: string, instance: I) => Output;
+
+export type AbstractMemoryRelayCallback<I, Output> = AbstractMemoryRelayCallbackQualify<I> | AbstractMemoryRelayCallbackInstatiate<I, Output>;

package/src/utils.ts

@@ -0,0 +1,88 @@
+import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
+import { EventKeyDataType, EventType } from "./types.js";
+import { Filter, NostrEvent } from "nostr-tools";
+import { IEvent } from "@nostrwatch/route66/models/Event";
+
+export const eventType = ( event: any ): EventType => {
+    if(isReplaceableKind(event.kind)) {
+        return 'replaceable';
+    }
+    else if(isParameterizedReplaceableKind(event.kind)){
+        return 'parameterized';
+    }
+    else {
+        return 'event'
+    }
+}
+
+export const eventAddr = ( event: any, type?: EventType ) => {
+    let { pubkey, kind } = event;
+    type = type ?? eventType(event);
+    pubkey = pubkey.slice(0,16);
+    if(type === 'parameterized') {
+        const dtag = event.tags.find((t: string[]) => t[0] === 'd')?.[1]
+        const key = `${pubkey}:${kind}:${dtag}`;
+        return key;
+    }
+    else if(type === 'replaceable') {
+        const key = `${pubkey}:${kind}`
+        return key;
+    }
+}
+
+export const eventKey = (event: any, type?: EventType) =>{
+    type = type ?? eventType(event);
+    if(type === 'replaceable') {
+        return eventAddr(event, type);
+    }
+    else if(type === 'parameterized') {
+        return eventAddr(event, type);
+    }
+    else {
+        return event.id
+    }
+}
+
+export const eventIdData = (event: any): EventKeyDataType => {
+    const type =  eventType(event)
+    return {
+        type,
+        key: eventKey(event, type)
+    }
+}
+
+export function eventMatchesFilter(ev: IEvent | NostrEvent | any, filter: Filter): boolean {
+    if (filter.since && ev.created_at < filter.since) {
+      return false;
+    }
+    if (filter.until && ev.created_at > filter.until) {
+      return false;
+    }
+    if (!(filter.ids?.includes(ev.id) ?? true)) {
+      return false;
+    }
+    if (!(filter.authors?.includes(ev.pubkey) ?? true)) {
+      return false;
+    }
+    if (!(filter.kinds?.includes(ev.kind) ?? true)) {
+      return false;
+    }
+    const orTags = Object.entries(filter).filter(([k]) => k.startsWith("#"));
+    for (const [k, v] of orTags) {
+      const vargs = v as Array<string>;
+      for (const x of vargs) {
+        if (!ev.tags.find((a: string[]) => a[0] === k.slice(1) && a[1] === x)) {
+          return false;
+        }
+      }
+    }
+    const andTags = Object.entries(filter).filter(([k]) => k.startsWith("&"));
+    for (const [k, v] of andTags) {
+      const vargs = v as Array<string>;
+      const allMatch = vargs.every(x => ev.tags.some((tag: string[]) => tag[0] === k.slice(1) && tag[1] === x));
+      if (!allMatch) {
+        return false;
+      }
+    }
+    return true;
+  }