@nostrify/policies 0.36.7 → 0.36.8

package/dist/PowPolicy.ts

@@ -0,0 +1,44 @@
+import type { NostrEvent, NostrRelayInfo, NostrRelayOK, NPolicy } from '@nostrify/types';
+import { nip13 } from 'nostr-tools';
+
+/** Policy options for `PowPolicy`. */
+interface PowPolicyOpts {
+  /** Events will be rejected if their `id` does not contain at least this many leading 0 bits. Default: `1` */
+  difficulty?: number;
+}
+
+/**
+ * Reject events which don't meet Proof-of-Work ([NIP-13](https://github.com/nostr-protocol/nips/blob/master/13.md)) criteria.
+ *
+ * ```ts
+ * new PowPolicy({ difficulty: 20 });
+ * ```
+ */
+export class PowPolicy implements NPolicy {
+  private opts: PowPolicyOpts;
+  constructor(opts: PowPolicyOpts = {}) {
+    this.opts = opts;
+  }
+
+  // deno-lint-ignore require-await
+  async call({ id, tags }: NostrEvent): Promise<NostrRelayOK> {
+    const { difficulty = 1 } = this.opts;
+
+    const pow = nip13.getPow(id);
+    const nonce = tags.find(([name]: string[]) => name === 'nonce');
+
+    if (pow >= difficulty && nonce && Number(nonce[2]) >= difficulty) {
+      return ['OK', id, true, ''];
+    }
+
+    return ['OK', id, false, `pow: insufficient proof-of-work (difficulty ${difficulty})`];
+  }
+
+  get info(): NostrRelayInfo {
+    return {
+      limitation: {
+        min_pow_difficulty: this.opts.difficulty,
+      },
+    };
+  }
+}

package/dist/PubkeyBanPolicy.d.ts

@@ -0,0 +1,15 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+/**
+ * Ban events from individual pubkeys.
+ *
+ * ```ts
+ * // Ban a specific pubkey.
+ * new PubkeyBanPolicy(['e810fafa1e89cdf80cced8e013938e87e21b699b24c8570537be92aec4b12c18']);
+ * ```
+ */
+export declare class PubkeyBanPolicy implements NPolicy {
+    private pubkeys;
+    constructor(pubkeys: Iterable<string>);
+    call({ id, pubkey }: NostrEvent): Promise<NostrRelayOK>;
+}
+//# sourceMappingURL=PubkeyBanPolicy.d.ts.map

package/dist/PubkeyBanPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PubkeyBanPolicy.d.ts","sourceRoot":"","sources":["../PubkeyBanPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzE;;;;;;;GAOG;AACH,qBAAa,eAAgB,YAAW,OAAO;IAC7C,OAAO,CAAC,OAAO,CAAmB;gBACtB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC;IAK/B,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;CAS9D"}

package/dist/PubkeyBanPolicy.js

@@ -0,0 +1,18 @@
+class PubkeyBanPolicy {
+  pubkeys;
+  constructor(pubkeys) {
+    this.pubkeys = pubkeys;
+  }
+  // deno-lint-ignore require-await
+  async call({ id, pubkey }) {
+    for (const p of this.pubkeys) {
+      if (p === pubkey) {
+        return ["OK", id, false, "blocked: pubkey is banned"];
+      }
+    }
+    return ["OK", id, true, ""];
+  }
+}
+export {
+  PubkeyBanPolicy
+};

package/dist/PubkeyBanPolicy.ts

@@ -0,0 +1,27 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/**
+ * Ban events from individual pubkeys.
+ *
+ * ```ts
+ * // Ban a specific pubkey.
+ * new PubkeyBanPolicy(['e810fafa1e89cdf80cced8e013938e87e21b699b24c8570537be92aec4b12c18']);
+ * ```
+ */
+export class PubkeyBanPolicy implements NPolicy {
+  private pubkeys: Iterable<string>;
+  constructor(pubkeys: Iterable<string>) {
+    this.pubkeys = pubkeys;
+  }
+
+  // deno-lint-ignore require-await
+  async call({ id, pubkey }: NostrEvent): Promise<NostrRelayOK> {
+    for (const p of this.pubkeys) {
+      if (p === pubkey) {
+        return ['OK', id, false, 'blocked: pubkey is banned'];
+      }
+    }
+
+    return ['OK', id, true, ''];
+  }
+}

package/dist/ReadOnlyPolicy.d.ts

@@ -0,0 +1,6 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+/** This policy rejects all messages. */
+export declare class ReadOnlyPolicy implements NPolicy {
+    call(event: NostrEvent): Promise<NostrRelayOK>;
+}
+//# sourceMappingURL=ReadOnlyPolicy.d.ts.map

package/dist/ReadOnlyPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReadOnlyPolicy.d.ts","sourceRoot":"","sources":["../ReadOnlyPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzE,wCAAwC;AACxC,qBAAa,cAAe,YAAW,OAAO;IAEtC,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;CAGrD"}

package/dist/ReadOnlyPolicy.js

@@ -0,0 +1,9 @@
+class ReadOnlyPolicy {
+  // deno-lint-ignore require-await
+  async call(event) {
+    return ["OK", event.id, false, "blocked: the relay is read-only"];
+  }
+}
+export {
+  ReadOnlyPolicy
+};

package/dist/ReadOnlyPolicy.ts

@@ -0,0 +1,9 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/** This policy rejects all messages. */
+export class ReadOnlyPolicy implements NPolicy {
+  // deno-lint-ignore require-await
+  async call(event: NostrEvent): Promise<NostrRelayOK> {
+    return ['OK', event.id, false, 'blocked: the relay is read-only'];
+  }
+}

package/dist/RegexPolicy.d.ts

@@ -0,0 +1,15 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+/**
+ * Reject events whose content matches the regex.
+ *
+ * ```ts
+ * // Ban events matching a regex.
+ * new RegexPolicy(/(🟠|🔥|😳)ChtaGPT/i);
+ * ```
+ */
+export declare class RegexPolicy implements NPolicy {
+    private regex;
+    constructor(regex: RegExp);
+    call({ id, content }: NostrEvent): Promise<NostrRelayOK>;
+}
+//# sourceMappingURL=RegexPolicy.d.ts.map

package/dist/RegexPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RegexPolicy.d.ts","sourceRoot":"","sources":["../RegexPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzE;;;;;;;GAOG;AACH,qBAAa,WAAY,YAAW,OAAO;IACzC,OAAO,CAAC,KAAK,CAAS;gBACV,KAAK,EAAE,MAAM;IAKnB,IAAI,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;CAO/D"}

package/dist/RegexPolicy.js

@@ -0,0 +1,16 @@
+class RegexPolicy {
+  regex;
+  constructor(regex) {
+    this.regex = regex;
+  }
+  // deno-lint-ignore require-await
+  async call({ id, content }) {
+    if (this.regex.test(content)) {
+      return ["OK", id, false, "blocked: text matches a banned expression"];
+    }
+    return ["OK", id, true, ""];
+  }
+}
+export {
+  RegexPolicy
+};

package/dist/RegexPolicy.ts

@@ -0,0 +1,25 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/**
+ * Reject events whose content matches the regex.
+ *
+ * ```ts
+ * // Ban events matching a regex.
+ * new RegexPolicy(/(🟠|🔥|😳)ChtaGPT/i);
+ * ```
+ */
+export class RegexPolicy implements NPolicy {
+  private regex: RegExp;
+  constructor(regex: RegExp) {
+    this.regex = regex;
+  }
+
+  // deno-lint-ignore require-await
+  async call({ id, content }: NostrEvent): Promise<NostrRelayOK> {
+    if (this.regex.test(content)) {
+      return ['OK', id, false, 'blocked: text matches a banned expression'];
+    }
+
+    return ['OK', id, true, ''];
+  }
+}

package/dist/ReplyBotPolicy.d.ts

@@ -0,0 +1,25 @@
+import type { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+/** Options for the ReplyBotPolicy. */
+export interface ReplyBotPolicyOpts {
+    /** The store to use for fetching events. */
+    store: NStore;
+    /** The minimum time in seconds between two posts. */
+    threshold?: number;
+    /** The kinds of events to apply the policy to. */
+    kinds?: number[];
+}
+/** Block events that reply too quickly to another event. */
+export declare class ReplyBotPolicy implements NPolicy {
+    private opts;
+    constructor(opts: ReplyBotPolicyOpts);
+    call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK>;
+    /** Tag is a NIP-10 root tag. */
+    private static isRootTag;
+    /** Tag is a NIP-10 reply tag. */
+    private static isReplyTag;
+    /** Tag is an "e" tag without a NIP-10 marker. */
+    private static isLegacyReplyTag;
+    /** Get the "e" tag for the event being replied to, first according to the NIPs then falling back to the legacy way. */
+    private static findReplyTag;
+}
+//# sourceMappingURL=ReplyBotPolicy.d.ts.map

package/dist/ReplyBotPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplyBotPolicy.d.ts","sourceRoot":"","sources":["../ReplyBotPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEjF,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,4DAA4D;AAC5D,qBAAa,cAAe,YAAW,OAAO;IAC5C,OAAO,CAAC,IAAI,CAAqB;gBACrB,IAAI,EAAE,kBAAkB;IAI9B,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;IAuB1E,gCAAgC;IAChC,OAAO,CAAC,MAAM,CAAC,SAAS;IAIxB,iCAAiC;IACjC,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB,iDAAiD;IACjD,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAI/B,uHAAuH;IACvH,OAAO,CAAC,MAAM,CAAC,YAAY;CAG5B"}

package/dist/ReplyBotPolicy.js

@@ -0,0 +1,42 @@
+class ReplyBotPolicy {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async call(event, signal) {
+    const { store, threshold = 1, kinds = [1] } = this.opts;
+    if (kinds.includes(event.kind)) {
+      const [, replyToId] = ReplyBotPolicy.findReplyTag(event.tags) ?? [];
+      if (replyToId) {
+        const [prevEvent] = await store.query([{ ids: [replyToId] }], { signal });
+        if (prevEvent) {
+          const diff = event.created_at - prevEvent.created_at;
+          const pTag = prevEvent.tags.find(([name, value]) => name === "p" && value === event.pubkey);
+          if (diff <= threshold && !pTag) {
+            return ["OK", event.id, false, "rate-limited: replied too quickly"];
+          }
+        }
+      }
+    }
+    return ["OK", event.id, true, ""];
+  }
+  /** Tag is a NIP-10 root tag. */
+  static isRootTag(tag) {
+    return tag[0] === "e" && tag[3] === "root";
+  }
+  /** Tag is a NIP-10 reply tag. */
+  static isReplyTag(tag) {
+    return tag[0] === "e" && tag[3] === "reply";
+  }
+  /** Tag is an "e" tag without a NIP-10 marker. */
+  static isLegacyReplyTag(tag) {
+    return tag[0] === "e" && !tag[3];
+  }
+  /** Get the "e" tag for the event being replied to, first according to the NIPs then falling back to the legacy way. */
+  static findReplyTag(tags) {
+    return tags.find(this.isReplyTag) || tags.find(this.isRootTag) || tags.findLast(this.isLegacyReplyTag);
+  }
+}
+export {
+  ReplyBotPolicy
+};

package/dist/ReplyBotPolicy.ts

@@ -0,0 +1,62 @@
+import type { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+
+/** Options for the ReplyBotPolicy. */
+export interface ReplyBotPolicyOpts {
+  /** The store to use for fetching events. */
+  store: NStore;
+  /** The minimum time in seconds between two posts. */
+  threshold?: number;
+  /** The kinds of events to apply the policy to. */
+  kinds?: number[];
+}
+
+/** Block events that reply too quickly to another event. */
+export class ReplyBotPolicy implements NPolicy {
+  private opts: ReplyBotPolicyOpts;
+  constructor(opts: ReplyBotPolicyOpts) {
+    this.opts = opts;
+  }
+
+  async call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK> {
+    const { store, threshold = 1, kinds = [1] } = this.opts;
+
+    if (kinds.includes(event.kind)) {
+      const [, replyToId] = ReplyBotPolicy.findReplyTag(event.tags) ?? [];
+
+      if (replyToId) {
+        const [prevEvent] = await store.query([{ ids: [replyToId] }], { signal });
+
+        if (prevEvent) {
+          const diff = event.created_at - prevEvent.created_at;
+          const pTag = prevEvent.tags.find(([name, value]: string[]) => name === 'p' && value === event.pubkey);
+
+          if (diff <= threshold && !pTag) {
+            return ['OK', event.id, false, 'rate-limited: replied too quickly'];
+          }
+        }
+      }
+    }
+
+    return ['OK', event.id, true, ''];
+  }
+
+  /** Tag is a NIP-10 root tag. */
+  private static isRootTag(tag: string[]): tag is ['e', string, string, 'root', ...string[]] {
+    return tag[0] === 'e' && tag[3] === 'root';
+  }
+
+  /** Tag is a NIP-10 reply tag. */
+  private static isReplyTag(tag: string[]): tag is ['e', string, string, 'reply', ...string[]] {
+    return tag[0] === 'e' && tag[3] === 'reply';
+  }
+
+  /** Tag is an "e" tag without a NIP-10 marker. */
+  private static isLegacyReplyTag(tag: string[]): tag is ['e', string, string] {
+    return tag[0] === 'e' && !tag[3];
+  }
+
+  /** Get the "e" tag for the event being replied to, first according to the NIPs then falling back to the legacy way. */
+  private static findReplyTag(tags: string[][]): ['e', ...string[]] | undefined {
+    return tags.find(this.isReplyTag) || tags.find(this.isRootTag) || tags.findLast(this.isLegacyReplyTag);
+  }
+}

package/dist/SizePolicy.d.ts

@@ -0,0 +1,23 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+/** Policy options for `SizePolicy`. */
+interface SizePolicyOpts {
+    /** Maximum size of the message content in bytes. Default: 8192 (8KB) */
+    maxBytes?: number;
+}
+/**
+ * Reject events larger than a specified size in bytes.
+ *
+ * ```ts
+ * // Reject events larger than the default size (8KB) .
+ * new SizePolicy();
+ * // Reject events larger than a custom size (15KB).
+ * new SizePolicy({ maxBytes: 15 * 1024 });
+ * ```
+ */
+export declare class SizePolicy implements NPolicy {
+    private opts;
+    constructor(opts?: SizePolicyOpts);
+    call(event: NostrEvent): Promise<NostrRelayOK>;
+}
+export {};
+//# sourceMappingURL=SizePolicy.d.ts.map

package/dist/SizePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SizePolicy.d.ts","sourceRoot":"","sources":["../SizePolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzE,uCAAuC;AACvC,UAAU,cAAc;IACtB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,qBAAa,UAAW,YAAW,OAAO;IACxC,OAAO,CAAC,IAAI,CAAiB;gBAEjB,IAAI,GAAE,cAAmB;IAK/B,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;CAYrD"}

package/dist/SizePolicy.js

@@ -0,0 +1,19 @@
+class SizePolicy {
+  opts;
+  constructor(opts = {}) {
+    this.opts = opts;
+  }
+  // deno-lint-ignore require-await
+  async call(event) {
+    const { maxBytes = 8 * 1024 } = this.opts;
+    const json = JSON.stringify(event);
+    const size = new TextEncoder().encode(json).length;
+    if (size > maxBytes) {
+      return ["OK", event.id, false, `blocked: event is too large`];
+    }
+    return ["OK", event.id, true, ""];
+  }
+}
+export {
+  SizePolicy
+};

package/dist/SizePolicy.ts

@@ -0,0 +1,39 @@
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/** Policy options for `SizePolicy`. */
+interface SizePolicyOpts {
+  /** Maximum size of the message content in bytes. Default: 8192 (8KB) */
+  maxBytes?: number;
+}
+
+/**
+ * Reject events larger than a specified size in bytes.
+ *
+ * ```ts
+ * // Reject events larger than the default size (8KB) .
+ * new SizePolicy();
+ * // Reject events larger than a custom size (15KB).
+ * new SizePolicy({ maxBytes: 15 * 1024 });
+ * ```
+ */
+export class SizePolicy implements NPolicy {
+  private opts: SizePolicyOpts;
+
+  constructor(opts: SizePolicyOpts = {}) {
+    this.opts = opts;
+  }
+
+  // deno-lint-ignore require-await
+  async call(event: NostrEvent): Promise<NostrRelayOK> {
+    const { maxBytes = 8 * 1024 } = this.opts;
+
+    const json = JSON.stringify(event);
+    const size = new TextEncoder().encode(json).length;
+
+    if (size > maxBytes) {
+      return ['OK', event.id, false, `blocked: event is too large`];
+    }
+
+    return ['OK', event.id, true, ''];
+  }
+}

package/dist/WhitelistPolicy.d.ts

@@ -0,0 +1,16 @@
+import type { NostrEvent, NostrRelayInfo, NostrRelayOK, NPolicy } from '@nostrify/types';
+/**
+ * Allows only the listed pubkeys to post. All other events are rejected.
+ *
+ * ```ts
+ * // Only the given pubkey may post.
+ * new WhitelistPolicy(['e810fafa1e89cdf80cced8e013938e87e21b699b24c8570537be92aec4b12c18']);
+ * ```
+ */
+export declare class WhitelistPolicy implements NPolicy {
+    private pubkeys;
+    constructor(pubkeys: Iterable<string>);
+    call({ id, pubkey }: NostrEvent): Promise<NostrRelayOK>;
+    get info(): NostrRelayInfo;
+}
+//# sourceMappingURL=WhitelistPolicy.d.ts.map

package/dist/WhitelistPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WhitelistPolicy.d.ts","sourceRoot":"","sources":["../WhitelistPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEzF;;;;;;;GAOG;AACH,qBAAa,eAAgB,YAAW,OAAO;IAC7C,OAAO,CAAC,OAAO,CAAmB;gBAEtB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC;IAK/B,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAU7D,IAAI,IAAI,IAAI,cAAc,CAMzB;CACF"}

package/dist/WhitelistPolicy.js

@@ -0,0 +1,25 @@
+class WhitelistPolicy {
+  pubkeys;
+  constructor(pubkeys) {
+    this.pubkeys = pubkeys;
+  }
+  // deno-lint-ignore require-await
+  async call({ id, pubkey }) {
+    for (const p of this.pubkeys) {
+      if (p === pubkey) {
+        return ["OK", id, true, ""];
+      }
+    }
+    return ["OK", id, false, "blocked: only certain pubkeys are allowed to post"];
+  }
+  get info() {
+    return {
+      limitation: {
+        restricted_writes: true
+      }
+    };
+  }
+}
+export {
+  WhitelistPolicy
+};

package/dist/WhitelistPolicy.ts

@@ -0,0 +1,36 @@
+import type { NostrEvent, NostrRelayInfo, NostrRelayOK, NPolicy } from '@nostrify/types';
+
+/**
+ * Allows only the listed pubkeys to post. All other events are rejected.
+ *
+ * ```ts
+ * // Only the given pubkey may post.
+ * new WhitelistPolicy(['e810fafa1e89cdf80cced8e013938e87e21b699b24c8570537be92aec4b12c18']);
+ * ```
+ */
+export class WhitelistPolicy implements NPolicy {
+  private pubkeys: Iterable<string>;
+
+  constructor(pubkeys: Iterable<string>) {
+    this.pubkeys = pubkeys;
+  }
+
+  // deno-lint-ignore require-await
+  async call({ id, pubkey }: NostrEvent): Promise<NostrRelayOK> {
+    for (const p of this.pubkeys) {
+      if (p === pubkey) {
+        return ['OK', id, true, ''];
+      }
+    }
+
+    return ['OK', id, false, 'blocked: only certain pubkeys are allowed to post'];
+  }
+
+  get info(): NostrRelayInfo {
+    return {
+      limitation: {
+        restricted_writes: true,
+      },
+    };
+  }
+}

package/dist/WoTPolicy.d.ts

@@ -0,0 +1,26 @@
+import type { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+/** Options for the `WoTPolicy`. */
+interface WoTPolicyOpts {
+    /** Store to get kind 3 follow lists from. */
+    store: NStore;
+    /** Initial set of trusted pubkeys to query follow lists for. */
+    pubkeys: Iterable<string>;
+    /**
+     * How many levels of follow lists to query.
+     * `0` will just whitelist the given `pubkeys` without checking their follow lists.
+     * `1` will query their follows,
+     * `2` will query their follows follows, etc.
+     */
+    depth: number;
+}
+/** Whitelist pubkeys the given user follows, people those users follow, etc. up to `depth`. */
+export declare class WoTPolicy implements NPolicy {
+    private pubkeys;
+    private opts;
+    constructor(opts: WoTPolicyOpts);
+    call(event: NostrEvent): Promise<NostrRelayOK>;
+    /** Retrieve the complete set of pubkeys to whitelist. */
+    private getPubkeys;
+}
+export {};
+//# sourceMappingURL=WoTPolicy.d.ts.map

package/dist/WoTPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WoTPolicy.d.ts","sourceRoot":"","sources":["../WoTPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEjF,mCAAmC;AACnC,UAAU,aAAa;IACrB,6CAA6C;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,+FAA+F;AAC/F,qBAAa,SAAU,YAAW,OAAO;IACvC,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,IAAI,CAAgB;gBAEhB,IAAI,EAAE,aAAa;IAIzB,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC;IAWpD,yDAAyD;YAC3C,UAAU;CAyBzB"}

package/dist/WoTPolicy.js

@@ -0,0 +1,39 @@
+class WoTPolicy {
+  pubkeys;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async call(event) {
+    this.pubkeys ??= this.getPubkeys();
+    const pubkeys = await this.pubkeys;
+    if (pubkeys.has(event.pubkey)) {
+      return ["OK", event.id, true, ""];
+    }
+    return ["OK", event.id, false, "blocked: only certain pubkeys are allowed to post"];
+  }
+  /** Retrieve the complete set of pubkeys to whitelist. */
+  async getPubkeys() {
+    const { store, depth } = this.opts;
+    const pubkeys = /* @__PURE__ */ new Set([...this.opts.pubkeys]);
+    const authors = new Set(pubkeys);
+    for (let i = 0; i < depth; i++) {
+      const events = await store.query([{ kinds: [3], authors: [...authors] }]);
+      authors.clear();
+      for (const event of events) {
+        for (const [name, value] of event.tags) {
+          if (name === "p") {
+            if (!pubkeys.has(value)) {
+              authors.add(value);
+            }
+            pubkeys.add(value);
+          }
+        }
+      }
+    }
+    return pubkeys;
+  }
+}
+export {
+  WoTPolicy
+};

package/dist/WoTPolicy.ts

@@ -0,0 +1,64 @@
+import type { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+
+/** Options for the `WoTPolicy`. */
+interface WoTPolicyOpts {
+  /** Store to get kind 3 follow lists from. */
+  store: NStore;
+  /** Initial set of trusted pubkeys to query follow lists for. */
+  pubkeys: Iterable<string>;
+  /**
+   * How many levels of follow lists to query.
+   * `0` will just whitelist the given `pubkeys` without checking their follow lists.
+   * `1` will query their follows,
+   * `2` will query their follows follows, etc.
+   */
+  depth: number;
+}
+
+/** Whitelist pubkeys the given user follows, people those users follow, etc. up to `depth`. */
+export class WoTPolicy implements NPolicy {
+  private pubkeys: Promise<Set<string>> | undefined;
+  private opts: WoTPolicyOpts;
+
+  constructor(opts: WoTPolicyOpts) {
+    this.opts = opts;
+  }
+
+  async call(event: NostrEvent): Promise<NostrRelayOK> {
+    this.pubkeys ??= this.getPubkeys();
+    const pubkeys = await this.pubkeys;
+
+    if (pubkeys.has(event.pubkey)) {
+      return ['OK', event.id, true, ''];
+    }
+
+    return ['OK', event.id, false, 'blocked: only certain pubkeys are allowed to post'];
+  }
+
+  /** Retrieve the complete set of pubkeys to whitelist. */
+  private async getPubkeys(): Promise<Set<string>> {
+    const { store, depth } = this.opts;
+
+    const pubkeys = new Set<string>([...this.opts.pubkeys]);
+    const authors = new Set(pubkeys);
+
+    for (let i = 0; i < depth; i++) {
+      const events = await store.query([{ kinds: [3], authors: [...authors] }]);
+
+      authors.clear();
+
+      for (const event of events) {
+        for (const [name, value] of event.tags) {
+          if (name === 'p') {
+            if (!pubkeys.has(value)) { // Avoid infinite loops.
+              authors.add(value);
+            }
+            pubkeys.add(value);
+          }
+        }
+      }
+    }
+
+    return pubkeys;
+  }
+}