@nostrify/policies 0.36.4 → 0.36.6

package/KeywordPolicy.test.ts

@@ -1,28 +1,34 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { KeywordPolicy } from './KeywordPolicy.ts';
+import { KeywordPolicy } from "./KeywordPolicy.ts";
 
-Deno.test('KeywordPolicy', async () => {
-  const words = ['https://t.me/spam', 'hello world'];
+await test("KeywordPolicy", async () => {
+  const words = ["https://t.me/spam", "hello world"];
 
   const event1 = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const event2 = finalizeEvent(
-    { kind: 1, content: '🔥🔥🔥 https://t.me/spam 我想死', tags: [], created_at: 0 },
+    {
+      kind: 1,
+      content: "🔥🔥🔥 https://t.me/spam 我想死",
+      tags: [],
+      created_at: 0,
+    },
     generateSecretKey(),
   );
 
   const event3 = finalizeEvent(
-    { kind: 1, content: 'hElLo wOrLd!', tags: [], created_at: 0 },
+    { kind: 1, content: "hElLo wOrLd!", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
-  assertEquals((await new KeywordPolicy(words).call(event1))[2], true);
-  assertEquals((await new KeywordPolicy(words).call(event2))[2], false);
-  assertEquals((await new KeywordPolicy([]).call(event2))[2], true);
-  assertEquals((await new KeywordPolicy(words).call(event3))[2], false);
+  deepStrictEqual((await new KeywordPolicy(words).call(event1))[2], true);
+  deepStrictEqual((await new KeywordPolicy(words).call(event2))[2], false);
+  deepStrictEqual((await new KeywordPolicy([]).call(event2))[2], true);
+  deepStrictEqual((await new KeywordPolicy(words).call(event3))[2], false);
 });

package/KeywordPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Reject events containing any of the strings in its content.
@@ -10,7 +10,10 @@ import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
  * ```
  */
 export class KeywordPolicy implements NPolicy {
-  constructor(private words: Iterable<string>) {}
+  private words: Iterable<string>;
+  constructor(words: Iterable<string>) {
+    this.words = words;
+  }
 
   // deno-lint-ignore require-await
   async call({ id, content }: NostrEvent): Promise<NostrRelayOK> {

package/NoOpPolicy.test.ts

@@ -1,18 +1,19 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { NoOpPolicy } from './NoOpPolicy.ts';
+import { NoOpPolicy } from "./NoOpPolicy.ts";
 
-Deno.test('NoOpPolicy', async () => {
+await test("NoOpPolicy", async () => {
   const policy = new NoOpPolicy();
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, eventId, ok] = await policy.call(event);
 
-  assertEquals(eventId, event.id);
-  assertEquals(ok, true);
+  deepStrictEqual(eventId, event.id);
+  deepStrictEqual(ok, true);
 });

package/NoOpPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /** Basic policy to demonstrate how policies work. Accepts all events. */
 export class NoOpPolicy implements NPolicy {

package/OpenAIPolicy.test.ts

@@ -1,13 +1,14 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { OpenAIPolicy } from './OpenAIPolicy.ts';
+import { OpenAIPolicy } from "./OpenAIPolicy.ts";
 
 const timeout = 50;
 
-Deno.test('rejects flagged events', async () => {
+await test("rejects flagged events", async () => {
   const event = finalizeEvent(
-    { kind: 1, content: 'I want to kill them.', tags: [], created_at: 0 },
+    { kind: 1, content: "I want to kill them.", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
@@ -18,14 +19,20 @@ Deno.test('rejects flagged events', async () => {
       ),
     );
 
-  assertEquals((await new OpenAIPolicy({ apiKey: '', fetch }).call(event, AbortSignal.timeout(timeout)))[2], false);
+  deepStrictEqual(
+    (await new OpenAIPolicy({ apiKey: "", fetch }).call(
+      event,
+      AbortSignal.timeout(timeout),
+    ))[2],
+    false,
+  );
 
   await new Promise((resolve) => setTimeout(resolve, timeout));
 });
 
-Deno.test('accepts unflagged events', async () => {
+await test("accepts unflagged events", async () => {
   const event = finalizeEvent(
-    { kind: 1, content: 'I want to love them.', tags: [], created_at: 0 },
+    { kind: 1, content: "I want to love them.", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
@@ -36,7 +43,13 @@ Deno.test('accepts unflagged events', async () => {
       ),
     );
 
-  assertEquals((await new OpenAIPolicy({ apiKey: '', fetch }).call(event, AbortSignal.timeout(timeout)))[2], false);
+  deepStrictEqual(
+    (await new OpenAIPolicy({ apiKey: "", fetch }).call(
+      event,
+      AbortSignal.timeout(timeout),
+    ))[2],
+    false,
+  );
 
   await new Promise((resolve) => setTimeout(resolve, timeout));
 });

package/OpenAIPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * OpenAI moderation result.
@@ -75,7 +75,10 @@ interface OpenAIPolicyOpts {
  * ```
  */
 export class OpenAIPolicy implements NPolicy {
-  constructor(private opts: OpenAIPolicyOpts) {}
+  private opts: OpenAIPolicyOpts;
+  constructor(opts: OpenAIPolicyOpts) {
+    this.opts = opts;
+  }
 
   async call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK> {
     const {

package/PipePolicy.test.ts

@@ -1,45 +1,46 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { NoOpPolicy } from './NoOpPolicy.ts';
-import { PipePolicy } from './PipePolicy.ts';
-import { ReadOnlyPolicy } from './ReadOnlyPolicy.ts';
+import { NoOpPolicy } from "./NoOpPolicy.ts";
+import { PipePolicy } from "./PipePolicy.ts";
+import { ReadOnlyPolicy } from "./ReadOnlyPolicy.ts";
 
-Deno.test('passes events through multiple policies', async () => {
+await test("passes events through multiple policies", async () => {
   const policy = new PipePolicy([
     new NoOpPolicy(),
     new ReadOnlyPolicy(),
   ]);
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, _eventId, ok, reason] = await policy.call(event);
 
-  assertEquals(ok, false);
-  assertEquals(reason, 'blocked: the relay is read-only');
+  deepStrictEqual(ok, false);
+  deepStrictEqual(reason, "blocked: the relay is read-only");
 });
 
-Deno.test('short-circuits on the first reject', async () => {
+await test("short-circuits on the first reject", async () => {
   const policy = new PipePolicy([
     new ReadOnlyPolicy(),
     new NoOpPolicy(),
   ]);
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, _eventId, ok, reason] = await policy.call(event);
 
-  assertEquals(ok, false);
-  assertEquals(reason, 'blocked: the relay is read-only');
+  deepStrictEqual(ok, false);
+  deepStrictEqual(reason, "blocked: the relay is read-only");
 });
 
-Deno.test('accepts when all policies accept', async () => {
+await test("accepts when all policies accept", async () => {
   const policy = new PipePolicy([
     new NoOpPolicy(),
     new NoOpPolicy(),
@@ -47,12 +48,12 @@ Deno.test('accepts when all policies accept', async () => {
   ]);
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, _eventId, ok, reason] = await policy.call(event);
 
-  assertEquals(ok, true);
-  assertEquals(reason, '');
+  deepStrictEqual(ok, true);
+  deepStrictEqual(reason, "");
 });

package/PipePolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Processes events through multiple policies.
@@ -20,7 +20,10 @@ import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
  * ```
  */
 export class PipePolicy implements NPolicy {
-  constructor(private policies: NPolicy[]) {}
+  private policies: NPolicy[] = [];
+  constructor(policies: NPolicy[]) {
+    this.policies = policies;
+  }
 
   async call(event: NostrEvent, signal?: AbortSignal): Promise<NostrRelayOK> {
     for (const policy of this.policies) {

package/PowPolicy.test.ts

@@ -1,27 +1,28 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { PowPolicy } from './PowPolicy.ts';
+import { PowPolicy } from "./PowPolicy.ts";
 
-Deno.test('blocks events without a nonce', async () => {
+await test("blocks events without a nonce", async () => {
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
-  assertEquals((await new PowPolicy().call(event))[2], false);
+  deepStrictEqual((await new PowPolicy().call(event))[2], false);
 });
 
-Deno.test('accepts event with sufficient POW', async () => {
+await test("accepts event with sufficient POW", async () => {
   const event = {
-    id: '000006d8c378af1779d2feebc7603a125d99eca0ccf1085959b307f64e5dd358',
-    tags: [['nonce', '776797', '20']],
+    id: "000006d8c378af1779d2feebc7603a125d99eca0ccf1085959b307f64e5dd358",
+    tags: [["nonce", "776797", "20"]],
     kind: 1,
-    content: '',
-    pubkey: '',
+    content: "",
+    pubkey: "",
     created_at: 0,
-    sig: '',
+    sig: "",
   };
 
-  assertEquals((await new PowPolicy().call(event))[2], true);
+  deepStrictEqual((await new PowPolicy().call(event))[2], true);
 });

package/PowPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayInfo, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayInfo, NostrRelayOK, NPolicy } from '@nostrify/types';
 import { nip13 } from 'nostr-tools';
 
 /** Policy options for `PowPolicy`. */
@@ -15,14 +15,17 @@ interface PowPolicyOpts {
  * ```
  */
 export class PowPolicy implements NPolicy {
-  constructor(private opts: PowPolicyOpts = {}) {}
+  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]) => name === 'nonce');
+    const nonce = tags.find(([name]: string[]) => name === 'nonce');
 
     if (pow >= difficulty && nonce && Number(nonce[2]) >= difficulty) {
       return ['OK', id, true, ''];

package/PubkeyBanPolicy.test.ts

@@ -1,17 +1,24 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { PubkeyBanPolicy } from './PubkeyBanPolicy.ts';
+import { PubkeyBanPolicy } from "./PubkeyBanPolicy.ts";
 
-Deno.test('PubkeyBanPolicy', async () => {
+await test("PubkeyBanPolicy", async () => {
   const [event1, event2, event3] = new Array(3).fill(0).map(() => {
     return finalizeEvent(
-      { kind: 1, content: '', tags: [], created_at: 0 },
+      { kind: 1, content: "", tags: [], created_at: 0 },
       generateSecretKey(),
     );
   });
 
-  assertEquals((await new PubkeyBanPolicy([]).call(event1))[2], true);
-  assertEquals((await new PubkeyBanPolicy([event2.pubkey, event1.pubkey]).call(event3))[2], true);
-  assertEquals((await new PubkeyBanPolicy([event2.pubkey, event1.pubkey]).call(event2))[2], false);
+  deepStrictEqual((await new PubkeyBanPolicy([]).call(event1))[2], true);
+  deepStrictEqual(
+    (await new PubkeyBanPolicy([event2.pubkey, event1.pubkey]).call(event3))[2],
+    true,
+  );
+  deepStrictEqual(
+    (await new PubkeyBanPolicy([event2.pubkey, event1.pubkey]).call(event2))[2],
+    false,
+  );
 });

package/PubkeyBanPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Ban events from individual pubkeys.
@@ -9,7 +9,10 @@ import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
  * ```
  */
 export class PubkeyBanPolicy implements NPolicy {
-  constructor(private pubkeys: Iterable<string>) {}
+  private pubkeys: Iterable<string>;
+  constructor(pubkeys: Iterable<string>) {
+    this.pubkeys = pubkeys;
+  }
 
   // deno-lint-ignore require-await
   async call({ id, pubkey }: NostrEvent): Promise<NostrRelayOK> {

package/ReadOnlyPolicy.test.ts

@@ -1,19 +1,20 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { ReadOnlyPolicy } from './ReadOnlyPolicy.ts';
+import { ReadOnlyPolicy } from "./ReadOnlyPolicy.ts";
 
-Deno.test('ReadOnlyPolicy', async () => {
+await test("ReadOnlyPolicy", async () => {
   const policy = new ReadOnlyPolicy();
 
   const event = finalizeEvent(
-    { kind: 1, content: '', tags: [], created_at: 0 },
+    { kind: 1, content: "", tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const [_, eventId, ok, reason] = await policy.call(event);
 
-  assertEquals(eventId, event.id);
-  assertEquals(reason, 'blocked: the relay is read-only');
-  assertEquals(ok, false);
+  deepStrictEqual(eventId, event.id);
+  deepStrictEqual(reason, "blocked: the relay is read-only");
+  deepStrictEqual(ok, false);
 });

package/ReadOnlyPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /** This policy rejects all messages. */
 export class ReadOnlyPolicy implements NPolicy {

package/RegexPolicy.test.ts

@@ -1,17 +1,26 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { RegexPolicy } from './RegexPolicy.ts';
+import { RegexPolicy } from "./RegexPolicy.ts";
 
-Deno.test('RegexPolicy', async () => {
+await test("RegexPolicy", async () => {
   const event = finalizeEvent(
-    { kind: 1, content: '🔥🔥🔥 https://t.me/spam 我想死', tags: [], created_at: 0 },
+    {
+      kind: 1,
+      content: "🔥🔥🔥 https://t.me/spam 我想死",
+      tags: [],
+      created_at: 0,
+    },
     generateSecretKey(),
   );
 
-  assertEquals((await new RegexPolicy(/https:\/\/t\.me\/\w+/i).call(event))[2], false);
-  assertEquals((await new RegexPolicy(/🔥{1,3}/).call(event))[2], false);
-  assertEquals((await new RegexPolicy(/🔥{4}/).call(event))[2], true);
-  assertEquals((await new RegexPolicy(/🔥$/).call(event))[2], true);
-  assertEquals((await new RegexPolicy(/^🔥/).call(event))[2], false);
+  deepStrictEqual(
+    (await new RegexPolicy(/https:\/\/t\.me\/\w+/i).call(event))[2],
+    false,
+  );
+  deepStrictEqual((await new RegexPolicy(/🔥{1,3}/).call(event))[2], false);
+  deepStrictEqual((await new RegexPolicy(/🔥{4}/).call(event))[2], true);
+  deepStrictEqual((await new RegexPolicy(/🔥$/).call(event))[2], true);
+  deepStrictEqual((await new RegexPolicy(/^🔥/).call(event))[2], false);
 });

package/RegexPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
 
 /**
  * Reject events whose content matches the regex.
@@ -9,7 +9,10 @@ import { NostrEvent, NostrRelayOK, NPolicy } from '@nostrify/types';
  * ```
  */
 export class RegexPolicy implements NPolicy {
-  constructor(private regex: RegExp) {}
+  private regex: RegExp;
+  constructor(regex: RegExp) {
+    this.regex = regex;
+  }
 
   // deno-lint-ignore require-await
   async call({ id, content }: NostrEvent): Promise<NostrRelayOK> {

package/ReplyBotPolicy.test.ts

@@ -1,50 +1,66 @@
-import { assertEquals } from '@std/assert';
-import { genEvent, MockRelay } from '@nostrify/nostrify/test';
-import { generateSecretKey, getPublicKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { genEvent, MockRelay } from "@nostrify/nostrify/test";
+import { generateSecretKey, getPublicKey } from "nostr-tools";
 
-import { ReplyBotPolicy } from './ReplyBotPolicy.ts';
+import { ReplyBotPolicy } from "./ReplyBotPolicy.ts";
 
-Deno.test('ReplyBotPolicy blocks replies within the same second', async () => {
+await test("ReplyBotPolicy blocks replies within the same second", async () => {
   const store = new MockRelay();
-  const policy = new ReplyBotPolicy({ store });
+  try {
+    const policy = new ReplyBotPolicy({ store });
 
-  const event = genEvent({ kind: 1, created_at: 0 });
-  const reply = genEvent({ kind: 1, created_at: 1, tags: [['e', event.id]] });
+    const event = genEvent({ kind: 1, created_at: 0 });
+    const reply = genEvent({ kind: 1, created_at: 1, tags: [["e", event.id]] });
 
-  await store.event(event);
+    await store.event(event);
 
-  const [, , ok] = await policy.call(reply);
+    const [, , ok] = await policy.call(reply);
 
-  assertEquals(ok, false);
+    deepStrictEqual(ok, false);
+  } finally {
+    await store.close();
+  }
 });
 
-Deno.test('ReplyBotPolicy allows replies after 1 second', async () => {
+await test("ReplyBotPolicy allows replies after 1 second", async () => {
   const store = new MockRelay();
-  const policy = new ReplyBotPolicy({ store });
+  try {
+    const policy = new ReplyBotPolicy({ store });
 
-  const event = genEvent({ kind: 1, created_at: 0 });
-  const reply = genEvent({ kind: 1, created_at: 2, tags: [['e', event.id]] });
+    const event = genEvent({ kind: 1, created_at: 0 });
+    const reply = genEvent({ kind: 1, created_at: 2, tags: [["e", event.id]] });
 
-  await store.event(event);
+    await store.event(event);
 
-  const [, , ok] = await policy.call(reply);
+    const [, , ok] = await policy.call(reply);
 
-  assertEquals(ok, true);
+    deepStrictEqual(ok, true);
+  } finally {
+    await store.close();
+  }
 });
 
-Deno.test('ReplyBotPolicy allows replies within the same second from users who are tagged', async () => {
+await test("ReplyBotPolicy allows replies within the same second from users who are tagged", async () => {
   const store = new MockRelay();
-  const policy = new ReplyBotPolicy({ store });
+  try {
+    const policy = new ReplyBotPolicy({ store });
 
-  const sk = generateSecretKey();
-  const pubkey = getPublicKey(sk);
+    const sk = generateSecretKey();
+    const pubkey = getPublicKey(sk);
 
-  const event = genEvent({ kind: 1, created_at: 0, tags: [['p', pubkey]] });
-  const reply = genEvent({ kind: 1, created_at: 1, tags: [['e', event.id]] }, sk);
+    const event = genEvent({ kind: 1, created_at: 0, tags: [["p", pubkey]] });
+    const reply = genEvent(
+      { kind: 1, created_at: 1, tags: [["e", event.id]] },
+      sk,
+    );
 
-  await store.event(event);
+    await store.event(event);
 
-  const [, , ok] = await policy.call(reply);
+    const [, , ok] = await policy.call(reply);
 
-  assertEquals(ok, true);
+    deepStrictEqual(ok, true);
+  } finally {
+    await store.close();
+  }
 });

package/ReplyBotPolicy.ts

@@ -1,4 +1,4 @@
-import { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
+import type { NostrEvent, NostrRelayOK, NPolicy, NStore } from '@nostrify/types';
 
 /** Options for the ReplyBotPolicy. */
 export interface ReplyBotPolicyOpts {
@@ -12,7 +12,10 @@ export interface ReplyBotPolicyOpts {
 
 /** Block events that reply too quickly to another event. */
 export class ReplyBotPolicy implements NPolicy {
-  constructor(private opts: ReplyBotPolicyOpts) {}
+  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;
@@ -25,7 +28,7 @@ export class ReplyBotPolicy implements NPolicy {
 
         if (prevEvent) {
           const diff = event.created_at - prevEvent.created_at;
-          const pTag = prevEvent.tags.find(([name, value]) => name === 'p' && value === event.pubkey);
+          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'];

package/SizePolicy.test.ts

@@ -1,21 +1,22 @@
-import { assertEquals } from '@std/assert';
-import { finalizeEvent, generateSecretKey } from 'nostr-tools';
+import { test } from "node:test";
+import { deepStrictEqual } from "node:assert";
+import { finalizeEvent, generateSecretKey } from "nostr-tools";
 
-import { SizePolicy } from './SizePolicy.ts';
+import { SizePolicy } from "./SizePolicy.ts";
 
-Deno.test('SizePolicy', async () => {
+await test("SizePolicy", async () => {
   const policy = new SizePolicy();
 
   const event = finalizeEvent(
-    { kind: 1, content: 'yolo'.repeat(100), tags: [], created_at: 0 },
+    { kind: 1, content: "yolo".repeat(100), tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
   const bigEvent = finalizeEvent(
-    { kind: 1, content: 'yolo'.repeat(2500), tags: [], created_at: 0 },
+    { kind: 1, content: "yolo".repeat(2500), tags: [], created_at: 0 },
     generateSecretKey(),
   );
 
-  assertEquals((await policy.call(event))[2], true);
-  assertEquals((await policy.call(bigEvent))[2], false);
+  deepStrictEqual((await policy.call(event))[2], true);
+  deepStrictEqual((await policy.call(bigEvent))[2], false);
 });