applesauce-actions 0.11.0 → 1.0.0

package/README.md

@@ -0,0 +1,42 @@
+# Applesauce Actions
+
+A collection of pre-built actions nostr clients can use. Built on top of `applesauce-core` and `applesauce-factory`.
+
+[Documentation](https://hzrd149.github.io/applesauce/typedoc/modules/applesauce_actions.html)
+
+## Installation
+
+```bash
+npm install applesauce-actions
+```
+
+## Overview
+
+Actions are common pre-built async operations that apps can perform. They use:
+
+- `EventStore` for access to known nostr events
+- `EventFactory` to build and sign new nostr events
+- A `publish` method to publish or save the resulting events
+
+The package provides an `ActionHub` class that combines these components into a single manager for easier action execution.
+
+## Basic Usage
+
+```typescript
+import { ActionHub } from "applesauce-actions";
+import { FollowUser } from "applesauce-actions/actions";
+
+async function publishEvent(event: NostrEvent) {
+  await relayPool.publish(event, ["wss://relay.example.com"]);
+}
+
+// Create an action hub with your event store, factory and publish method
+const hub = new ActionHub(eventStore, eventFactory, publishEvent);
+
+// Example: Follow a user
+await hub
+  .exec(FollowUser, "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d")
+  .forEach((event) => publishEvent(event));
+```
+
+For more detailed documentation and examples, visit the [full documentation](https://hzrd149.github.io/applesauce/overview/actions.html).

package/dist/__tests__/action-hub.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/action-hub.test.js

@@ -0,0 +1,67 @@
+import { from, Subject } from "rxjs";
+import { describe, expect, it, vi } from "vitest";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { EventFactory } from "applesauce-factory";
+import { EventStore } from "applesauce-core";
+import { FakeUser } from "./fake-user.js";
+import { ActionHub } from "../action-hub.js";
+import { CreateProfile } from "../actions/profile.js";
+const user = new FakeUser();
+const events = new EventStore();
+const factory = new EventFactory({ signer: user });
+describe("runAction", () => {
+    it("should handle action that return observables", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        const action = () => from(e);
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+    it("should handle action that return AsyncIterable", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        async function* action() {
+            for (const event of e)
+                yield event;
+        }
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+    it("should handle action that return Iterable", async () => {
+        const e = [user.note(), user.profile({ name: "testing" })];
+        function* action() {
+            for (const event of e)
+                yield event;
+        }
+        const spy = subscribeSpyTo(ActionHub.runAction({ events, factory, self: await user.getPublicKey() }, action));
+        await spy.onComplete();
+        expect(spy.getValues()).toEqual(e);
+    });
+});
+describe("run", () => {
+    it("should throw if publish is not set", async () => {
+        const hub = new ActionHub(events, factory);
+        await expect(async () => hub.run(CreateProfile, { name: "fiatjaf" })).rejects.toThrow();
+    });
+    it("should call publish with all events", async () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const hub = new ActionHub(events, factory, publish);
+        await hub.run(CreateProfile, { name: "fiatjaf" });
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) }));
+    });
+});
+describe("exec", () => {
+    it("should support forEach to stream to publish", async () => {
+        const publish = vi.fn().mockResolvedValue(undefined);
+        const hub = new ActionHub(events, factory);
+        await hub.exec(CreateProfile, { name: "fiatjaf" }).forEach(publish);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) }));
+    });
+    it("should support streaming to a publish subject", async () => {
+        const publish = new Subject();
+        const spy = subscribeSpyTo(publish);
+        const hub = new ActionHub(events, factory);
+        await hub.exec(CreateProfile, { name: "fiatjaf" }).forEach((v) => publish.next(v));
+        expect(spy.getValues()).toEqual([expect.objectContaining({ content: JSON.stringify({ name: "fiatjaf" }) })]);
+    });
+});

package/dist/__tests__/fake-user.d.ts

@@ -0,0 +1,10 @@
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import type { NostrEvent } from "nostr-tools";
+export declare class FakeUser extends SimpleSigner {
+    pubkey: string;
+    event(data?: Partial<NostrEvent>): NostrEvent;
+    note(content?: string, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    profile(profile: any, extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+    contacts(pubkeys?: string[]): import("nostr-tools").Event;
+    list(tags?: string[][], extra?: Partial<NostrEvent>): import("nostr-tools").Event;
+}

package/dist/__tests__/fake-user.js

@@ -0,0 +1,32 @@
+import { unixNow } from "applesauce-core/helpers";
+import { SimpleSigner } from "applesauce-signers/signers/simple-signer";
+import { nanoid } from "nanoid";
+import { finalizeEvent, getPublicKey, kinds } from "nostr-tools";
+export class FakeUser extends SimpleSigner {
+    pubkey = getPublicKey(this.key);
+    event(data) {
+        return finalizeEvent({
+            kind: data?.kind ?? kinds.ShortTextNote,
+            content: data?.content || "",
+            created_at: data?.created_at ?? unixNow(),
+            tags: data?.tags || [],
+        }, this.key);
+    }
+    note(content = "Hello World", extra) {
+        return this.event({ kind: kinds.ShortTextNote, content, ...extra });
+    }
+    profile(profile, extra) {
+        return this.event({ kind: kinds.Metadata, content: JSON.stringify({ ...profile }), ...extra });
+    }
+    contacts(pubkeys = []) {
+        return this.event({ kind: kinds.Contacts, tags: pubkeys.map((p) => ["p", p]) });
+    }
+    list(tags = [], extra) {
+        return this.event({
+            kind: kinds.Bookmarksets,
+            content: "",
+            tags: [["d", nanoid()], ...tags],
+            ...extra,
+        });
+    }
+}

package/dist/action-hub.d.ts

@@ -0,0 +1,36 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "nostr-tools";
+import { ISyncEventStore } from "applesauce-core/event-store";
+import { EventFactory } from "applesauce-factory";
+/**
+ * A callback used to tell the upstream app to publish an event
+ * @param label a label describing what
+ */
+export type PublishMethod = (event: NostrEvent) => void | Promise<void>;
+/** The context that is passed to actions for them to use to preform actions */
+export type ActionContext = {
+    /** The event store to load events from */
+    events: ISyncEventStore;
+    /** The pubkey of the signer in the event factory */
+    self: string;
+    /** The event factory used to build and modify events */
+    factory: EventFactory;
+};
+/** An action that can be run in a context to preform an action */
+export type Action = (ctx: ActionContext) => Observable<NostrEvent> | AsyncGenerator<NostrEvent> | Generator<NostrEvent>;
+export type ActionConstructor<Args extends Array<any>> = (...args: Args) => Action;
+/** The main class that runs actions */
+export declare class ActionHub {
+    events: ISyncEventStore;
+    factory: EventFactory;
+    publish?: PublishMethod | undefined;
+    constructor(events: ISyncEventStore, factory: EventFactory, publish?: PublishMethod | undefined);
+    protected context: ActionContext | undefined;
+    protected getContext(): Promise<ActionContext>;
+    /** Runs an action in a ActionContext and converts the result to an Observable */
+    static runAction(ctx: ActionContext, action: Action): Observable<NostrEvent>;
+    /** Run an action and publish events using the publish method */
+    run<Args extends Array<any>>(Action: ActionConstructor<Args>, ...args: Args): Promise<void>;
+    /** Run an action without publishing the events */
+    exec<Args extends Array<any>>(Action: ActionConstructor<Args>, ...args: Args): Observable<NostrEvent>;
+}

package/dist/action-hub.js

@@ -0,0 +1,49 @@
+import { from, isObservable, lastValueFrom, switchMap, toArray } from "rxjs";
+/** The main class that runs actions */
+export class ActionHub {
+    events;
+    factory;
+    publish;
+    constructor(events, factory, publish) {
+        this.events = events;
+        this.factory = factory;
+        this.publish = publish;
+    }
+    context = undefined;
+    async getContext() {
+        if (this.context)
+            return this.context;
+        else {
+            if (!this.factory.context.signer)
+                throw new Error("Missing signer");
+            const self = await this.factory.context.signer.getPublicKey();
+            this.context = { self, events: this.events, factory: this.factory };
+            return this.context;
+        }
+    }
+    /** Runs an action in a ActionContext and converts the result to an Observable */
+    static runAction(ctx, action) {
+        const result = action(ctx);
+        if (isObservable(result))
+            return result;
+        else
+            return from(result);
+    }
+    /** Run an action and publish events using the publish method */
+    async run(Action, ...args) {
+        if (!this.publish)
+            throw new Error("Missing publish method, use ActionHub.exec");
+        // wait for action to complete and group events
+        const events = await lastValueFrom(this.exec(Action, ...args).pipe(toArray()));
+        // publish events
+        for (const event of events)
+            await this.publish(event);
+    }
+    /** Run an action without publishing the events */
+    exec(Action, ...args) {
+        return from(this.getContext()).pipe(switchMap((ctx) => {
+            const action = Action(...args);
+            return ActionHub.runAction(ctx, action);
+        }));
+    }
+}

package/dist/actions/__tests__/blossom.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/__tests__/blossom.test.js

@@ -0,0 +1,93 @@
+import { EventStore } from "applesauce-core";
+import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-core/helpers/blossom";
+import { EventFactory } from "applesauce-factory";
+import { firstValueFrom, lastValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+import { beforeEach, describe, expect, it } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { AddBlossomServer, NewBlossomServers, RemoveBlossomServer, SetDefaultBlossomServer } from "../blossom.js";
+const user = new FakeUser();
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+});
+describe("NewBlossomServers", () => {
+    it("should publish a kind 10063 blossom server list", async () => {
+        const result = await lastValueFrom(hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).pipe(toArray()));
+        expect(result[0]).toMatchObject({ kind: BLOSSOM_SERVER_LIST_KIND, tags: [["server", "https://cdn.example.com/"]] });
+    });
+    it("should throw if a blossom servers event already exists", async () => {
+        // Create the initial event
+        await hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).forEach((e) => events.add(e));
+        // Attempt to create another one
+        await expect(lastValueFrom(hub.exec(NewBlossomServers, ["https://other.example.com/"]).pipe(toArray()))).rejects.toThrow("Blossom servers event already exists");
+    });
+});
+describe("AddBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial empty server list
+        await hub.exec(NewBlossomServers, ["https://cdn.example.com/"]).forEach((e) => events.add(e));
+    });
+    it("should add a single server to the list", async () => {
+        const result = await firstValueFrom(hub.exec(AddBlossomServer, "https://other.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([["server", expect.stringContaining("other.example.com")]]),
+        });
+    });
+    it("should add multiple servers to the list", async () => {
+        const result = await firstValueFrom(hub.exec(AddBlossomServer, ["https://other.example.com/", "https://other2.example.com/"]));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([
+                ["server", expect.stringContaining("other.example.com")],
+                ["server", expect.stringContaining("other2.example.com")],
+            ]),
+        });
+    });
+});
+describe("RemoveBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial server list with two servers
+        await hub
+            .exec(NewBlossomServers, ["https://cdn.example.com/", "https://other.example.com/"])
+            .forEach((e) => events.add(e));
+    });
+    it("should remove a server from the list", async () => {
+        const result = await firstValueFrom(hub.exec(RemoveBlossomServer, "https://cdn.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([["server", expect.stringContaining("other.example.com")]]),
+        });
+    });
+    it("should remove multiple servers from the list", async () => {
+        const result = await firstValueFrom(hub.exec(RemoveBlossomServer, ["https://cdn.example.com/", "https://other.example.com/"]));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: [],
+        });
+    });
+});
+describe("SetDefaultBlossomServer", () => {
+    beforeEach(async () => {
+        // Create an initial server list with two servers
+        await hub
+            .exec(NewBlossomServers, ["https://cdn.example.com/", "https://other.example.com/"])
+            .forEach((e) => events.add(e));
+    });
+    it("should move the specified server to the top of the list", async () => {
+        const result = await firstValueFrom(hub.exec(SetDefaultBlossomServer, "https://other.example.com/"));
+        expect(result).toMatchObject({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            tags: expect.arrayContaining([
+                ["server", expect.stringContaining("other.example.com")],
+                ["server", expect.stringContaining("cdn.example.com")],
+            ]),
+        });
+    });
+});

package/dist/actions/__tests__/bookmarks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/__tests__/bookmarks.test.js

@@ -0,0 +1,24 @@
+import { beforeEach, describe, expect, it, vitest } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { CreateBookmarkList } from "../bookmarks.js";
+const user = new FakeUser();
+let events;
+let factory;
+let publish;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    publish = vitest.fn().mockResolvedValue(undefined);
+    hub = new ActionHub(events, factory, publish);
+});
+describe("CreateBookmarkList", () => {
+    it("should publish a kind 10003 bookmark list", async () => {
+        await hub.run(CreateBookmarkList);
+        expect(publish).toBeCalledWith(expect.objectContaining({ kind: kinds.BookmarkList }));
+    });
+});

package/dist/actions/__tests__/contacts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/__tests__/contacts.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, beforeEach, vitest } from "vitest";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { EventFactory } from "applesauce-factory";
+import { EventStore } from "applesauce-core";
+import { ActionHub } from "../../action-hub.js";
+import { FollowUser, NewContacts, UnfollowUser } from "../contacts.js";
+const user = new FakeUser();
+let events;
+let factory;
+let publish;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    publish = vitest.fn().mockResolvedValue(undefined);
+    hub = new ActionHub(events, factory, publish);
+});
+describe("FollowUser", () => {
+    it("should throw an error if contacts does not exist", async () => {
+        // don't add any events to the store
+        await expect(hub.run(FollowUser, user.pubkey)).rejects.toThrow();
+        expect(publish).not.toHaveBeenCalled();
+    });
+    it('should publish an event with a new "p" tag', async () => {
+        events.add(user.contacts());
+        await hub.run(FollowUser, user.pubkey);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ tags: expect.arrayContaining([["p", user.pubkey]]) }));
+    });
+});
+describe("UnfollowUser", () => {
+    it("should throw an error if contacts does not exist", async () => {
+        // don't add any events to the store
+        await expect(hub.run(UnfollowUser, user.pubkey)).rejects.toThrow();
+        expect(publish).not.toHaveBeenCalled();
+    });
+    it('should publish an event with a new "p" tag', async () => {
+        events.add(user.contacts([user.pubkey]));
+        await hub.run(UnfollowUser, user.pubkey);
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: 3, tags: [] }));
+    });
+});
+describe("NewContacts", () => {
+    it("should throw if contact list already exists", async () => {
+        events.add(user.contacts([user.pubkey]));
+        await expect(hub.run(NewContacts, [])).rejects.toThrow();
+        expect(publish).not.toBeCalled();
+    });
+    it("should publish a new contact event with pubkeys", async () => {
+        await hub.run(NewContacts, [user.pubkey]);
+        expect(publish).toHaveBeenCalled();
+        expect(publish).toHaveBeenCalledWith(expect.objectContaining({ kind: 3, tags: expect.arrayContaining([["p", user.pubkey]]) }));
+    });
+});

package/dist/actions/__tests__/follow-sets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/__tests__/follow-sets.test.js

@@ -0,0 +1,80 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { unlockHiddenTags } from "applesauce-core/helpers";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { AddUserToFollowSet, RemoveUserFromFollowSet } from "../follow-sets.js";
+const user = new FakeUser();
+const testPubkey = "test-pubkey";
+const testIdentifier = "test-list";
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+    // Add a follow set event to work with
+    const followSet = user.event({
+        kind: kinds.Followsets,
+        tags: [["d", testIdentifier]],
+        content: "",
+        created_at: Math.floor(Date.now() / 1000),
+    });
+    events.add(followSet);
+});
+describe("AddUserToList", () => {
+    it("should add a pubkey to public tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(AddUserToFollowSet, testPubkey, testIdentifier), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(emittedEvent).toMatchObject({
+            kind: kinds.Followsets,
+            tags: expect.arrayContaining([
+                ["d", testIdentifier],
+                ["p", testPubkey],
+            ]),
+        });
+    });
+    it("should add a pubkey to hidden tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(AddUserToFollowSet, testPubkey, testIdentifier, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(await unlockHiddenTags(emittedEvent, user)).toEqual(expect.arrayContaining([["p", testPubkey]]));
+    });
+});
+describe("RemoveUserFromList", () => {
+    beforeEach(async () => {
+        // Add a follow set with existing tags to remove
+        const followSetWithTags = user.event({
+            kind: kinds.Followsets,
+            tags: [
+                ["d", testIdentifier],
+                ["p", testPubkey],
+            ],
+            content: await user.nip04.encrypt(user.pubkey, JSON.stringify(["p", testPubkey])),
+            created_at: Math.floor(Date.now() / 1000),
+        });
+        events.add(followSetWithTags);
+    });
+    it("should remove a pubkey from public tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(RemoveUserFromFollowSet, testPubkey, testIdentifier), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(emittedEvent).toMatchObject({
+            kind: kinds.Followsets,
+            tags: expect.not.arrayContaining([["p", testPubkey]]),
+        });
+    });
+    it("should remove a pubkey from hidden tags in a follow set", async () => {
+        const spy = subscribeSpyTo(hub.exec(RemoveUserFromFollowSet, testPubkey, testIdentifier, true), {
+            expectErrors: false,
+        });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        expect(await unlockHiddenTags(emittedEvent, user)).toEqual(expect.not.arrayContaining([["hidden", "p", testPubkey]]));
+    });
+});

package/dist/actions/__tests__/mute.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/actions/__tests__/mute.test.js

@@ -0,0 +1,67 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { EventStore } from "applesauce-core";
+import { EventFactory } from "applesauce-factory";
+import { kinds } from "nostr-tools";
+import { getMutedThings, getHiddenMutedThings } from "applesauce-core/helpers";
+import { subscribeSpyTo } from "@hirez_io/observer-spy";
+import { FakeUser } from "../../__tests__/fake-user.js";
+import { ActionHub } from "../../action-hub.js";
+import { MuteThread, UnmuteThread } from "../mute.js";
+const user = new FakeUser();
+const testEventId = "test-event-id";
+let events;
+let factory;
+let hub;
+beforeEach(() => {
+    events = new EventStore();
+    factory = new EventFactory({ signer: user });
+    hub = new ActionHub(events, factory);
+    // Add a mute list event to work with
+    const muteList = user.event({
+        kind: kinds.Mutelist,
+        tags: [],
+        content: "",
+        created_at: Math.floor(Date.now() / 1000),
+    });
+    events.add(muteList);
+});
+describe("MuteThread", () => {
+    it("should add an event to public tags in mute list", async () => {
+        const spy = subscribeSpyTo(hub.exec(MuteThread, testEventId), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const mutedThings = getMutedThings(emittedEvent);
+        expect(mutedThings.threads).toContain(testEventId);
+    });
+    it("should add an event to hidden tags in mute list", async () => {
+        const spy = subscribeSpyTo(hub.exec(MuteThread, testEventId, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const hiddenMutedThings = await getHiddenMutedThings(emittedEvent);
+        expect(hiddenMutedThings?.threads).toContain(testEventId);
+    });
+});
+describe("UnmuteThread", () => {
+    it("should remove an event from public tags in mute list", async () => {
+        // First add the thread to mute list
+        const addSpy = subscribeSpyTo(hub.exec(MuteThread, testEventId), { expectErrors: false });
+        await addSpy.onComplete();
+        // Then unmute it
+        const spy = subscribeSpyTo(hub.exec(UnmuteThread, testEventId), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const mutedThings = getMutedThings(emittedEvent);
+        expect(mutedThings.threads).not.toContain(testEventId);
+    });
+    it("should remove an event from hidden tags in mute list", async () => {
+        // First add the thread to hidden mute list
+        const addSpy = subscribeSpyTo(hub.exec(MuteThread, testEventId, true), { expectErrors: false });
+        await addSpy.onComplete();
+        // Then unmute it
+        const spy = subscribeSpyTo(hub.exec(UnmuteThread, testEventId, true), { expectErrors: false });
+        await spy.onComplete();
+        const emittedEvent = spy.getLastValue();
+        const hiddenMutedThings = await getHiddenMutedThings(emittedEvent);
+        expect(hiddenMutedThings?.threads).not.toContain(testEventId);
+    });
+});

package/dist/actions/blocked-relays.d.ts

@@ -0,0 +1,10 @@
+import { Action } from "../action-hub.js";
+/** An action that adds a relay to the 10006 blocked relays event */
+export declare function AddBlockedRelay(relay: string | string[], hidden?: boolean): Action;
+/** An action that removes a relay from the 10006 blocked relays event */
+export declare function RemoveBlockedRelay(relay: string | string[], hidden?: boolean): Action;
+/** Creates a new blocked relays event */
+export declare function NewBlockedRelays(relays?: string[] | {
+    public?: string[];
+    hidden?: string[];
+}): Action;

package/dist/actions/blocked-relays.js

@@ -0,0 +1,48 @@
+import { modifyHiddenTags, modifyPublicTags } from "applesauce-factory/operations/event";
+import { addRelayTag, removeRelayTag } from "applesauce-factory/operations/tag/relay";
+import { kinds } from "nostr-tools";
+function getBlockedRelaysEvent(events, self) {
+    const event = events.getReplaceable(kinds.BlockedRelaysList, self);
+    if (!event)
+        throw new Error("Can't find blocked relays event");
+    return event;
+}
+/** An action that adds a relay to the 10006 blocked relays event */
+export function AddBlockedRelay(relay, hidden = false) {
+    return async function* ({ events, factory, self }) {
+        const blocked = getBlockedRelaysEvent(events, self);
+        const operation = Array.isArray(relay) ? relay.map((r) => addRelayTag(r)) : addRelayTag(relay);
+        const draft = await factory.modifyTags(blocked, hidden ? { hidden: operation } : operation);
+        yield await factory.sign(draft);
+    };
+}
+/** An action that removes a relay from the 10006 blocked relays event */
+export function RemoveBlockedRelay(relay, hidden = false) {
+    return async function* ({ events, factory, self }) {
+        const blocked = getBlockedRelaysEvent(events, self);
+        const operation = Array.isArray(relay) ? relay.map((r) => removeRelayTag(r)) : removeRelayTag(relay);
+        const draft = await factory.modifyTags(blocked, hidden ? { hidden: operation } : operation);
+        yield await factory.sign(draft);
+    };
+}
+/** Creates a new blocked relays event */
+export function NewBlockedRelays(relays) {
+    return async function* ({ events, factory, self }) {
+        const blocked = events.getReplaceable(kinds.BlockedRelaysList, self);
+        if (blocked)
+            throw new Error("Blocked relays event already exists");
+        let publicOperations = [];
+        let hiddenOperations = [];
+        if (Array.isArray(relays)) {
+            publicOperations.push(...relays.map((r) => addRelayTag(r)));
+        }
+        else {
+            if (relays?.public)
+                publicOperations.push(...(relays?.public ?? []).map((r) => addRelayTag(r)));
+            if (relays?.hidden)
+                hiddenOperations.push(...(relays?.hidden ?? []).map((r) => addRelayTag(r)));
+        }
+        const draft = await factory.build({ kind: kinds.BlockedRelaysList }, publicOperations.length ? modifyPublicTags(...publicOperations) : undefined, hiddenOperations.length ? modifyHiddenTags(...hiddenOperations) : undefined);
+        yield await factory.sign(draft);
+    };
+}

package/dist/actions/blossom.d.ts

@@ -0,0 +1,9 @@
+import { Action } from "../action-hub.js";
+/** An action that adds a server to the Blossom servers event */
+export declare function AddBlossomServer(server: string | URL | (string | URL)[]): Action;
+/** An action that removes a server from the Blossom servers event */
+export declare function RemoveBlossomServer(server: string | URL | (string | URL)[]): Action;
+/** Makes a specific Blossom server the default server (move it to the top of the list) */
+export declare function SetDefaultBlossomServer(server: string | URL): Action;
+/** Creates a new Blossom servers event */
+export declare function NewBlossomServers(servers?: (string | URL)[]): Action;