@welshman/signer 0.0.15 → 0.0.17

package/build/src/signers/nip46.d.ts

@@ -1,30 +1,19 @@
 import { Emitter } from "@welshman/lib";
 import { TrustedEvent, StampedEvent } from "@welshman/util";
+import { Subscription } from "@welshman/net";
 import { ISigner } from '../util';
+import { Nip01Signer } from './nip01';
 export type Nip46Algorithm = "nip04" | "nip44";
-export type Nip46Handler = {
-    relays: string[];
-    pubkey: string;
-    domain?: string;
-};
-export type Nip46InitiateParams = {
-    url: string;
-    name: string;
-    image: string;
-    perms: string;
-    relays: string[];
-    abortController?: AbortController;
-};
+export declare enum Nip46Event {
+    Send = "send",
+    Receive = "receive"
+}
 export type Nip46BrokerParams = {
-    secret: string;
-    handler: Nip46Handler;
+    relays: string[];
+    clientSecret: string;
+    signerPubkey?: string;
     algorithm?: Nip46Algorithm;
 };
-export type Nip46Request = {
-    method: string;
-    params: string[];
-    resolve: (result: Nip46ResponseWithResult) => void;
-};
 export type Nip46Response = {
     id: string;
     url: string;
@@ -44,39 +33,69 @@ export type Nip46ResponseWithError = {
     event: TrustedEvent;
     error: string;
 };
+export declare class Nip46Receiver extends Emitter {
+    signer: ISigner;
+    params: Nip46BrokerParams;
+    sub?: Subscription;
+    constructor(signer: ISigner, params: Nip46BrokerParams);
+    start: () => Promise<void>;
+    stop: () => void;
+}
+export declare class Nip46Sender extends Emitter {
+    signer: ISigner;
+    params: Nip46BrokerParams;
+    processing: boolean;
+    queue: Nip46Request[];
+    constructor(signer: ISigner, params: Nip46BrokerParams);
+    send: (request: Nip46Request) => Promise<void>;
+    process: () => Promise<void>;
+    enqueue: (request: Nip46Request) => void;
+    stop: () => void;
+}
+export declare class Nip46Request {
+    readonly method: string;
+    readonly params: string[];
+    id: string;
+    promise: import("@welshman/lib").Deferred<Nip46ResponseWithResult, Nip46ResponseWithError>;
+    constructor(method: string, params: string[]);
+    listen: (receiver: Nip46Receiver) => Promise<void>;
+    send: (sender: Nip46Sender) => Promise<void>;
+}
 export declare class Nip46Broker extends Emitter {
-    #private;
-    private params;
-    static initiate({ url, name, image, perms, relays, abortController }: Nip46InitiateParams): {
-        result: Promise<string | undefined>;
-        params: URLSearchParams;
-        nostrconnect: string;
-        clientSecret: string;
-        clientPubkey: string;
-    };
-    static parseBunkerLink(link: string): {
-        token: string;
-        pubkey: string;
-        relays: string[];
-    };
-    static get(params: Nip46BrokerParams): Nip46Broker;
+    params: Nip46BrokerParams;
+    signer: ISigner;
+    sender: Nip46Sender;
+    receiver: Nip46Receiver;
     constructor(params: Nip46BrokerParams);
+    static get(params: Nip46BrokerParams): Nip46Broker;
     hasParams(params: Nip46BrokerParams): boolean;
-    request: (method: string, params: string[]) => Promise<Nip46ResponseWithResult>;
-    enqueue: (method: string, params: string[]) => Promise<Nip46ResponseWithResult>;
-    createAccount: (username: string, perms?: string) => Promise<string>;
-    connect: (token?: string, perms?: string, secret?: string) => Promise<boolean>;
+    makeSigner: () => Nip01Signer;
+    makeSender: () => Nip46Sender;
+    makeReceiver: () => Nip46Receiver;
+    setParams: (params: Partial<Nip46BrokerParams>) => void;
+    teardown: () => void;
+    enqueue: (method: string, params: string[]) => Promise<Nip46Request>;
+    send: (method: string, params: string[]) => Promise<string>;
+    parseBunkerUrl: (url: string) => {
+        signerPubkey: string;
+        connectSecret: string;
+        relays: string[];
+    };
+    makeNostrconnectUrl: (meta?: Record<string, string>) => Promise<string>;
+    waitForNostrconnect: (url: string, abort?: AbortController) => import("@welshman/lib").CustomPromise<Nip46ResponseWithResult, Nip46Response | undefined>;
+    ping: () => Promise<string>;
     getPublicKey: () => Promise<string>;
+    createAccount: (username: string, domain: string, perms?: string) => Promise<string>;
+    connect: (signerPubkey: string, connectSecret?: string, perms?: string) => Promise<string>;
     signEvent: (event: StampedEvent) => Promise<any>;
     nip04Encrypt: (pk: string, message: string) => Promise<string>;
     nip04Decrypt: (pk: string, message: string) => Promise<string>;
     nip44Encrypt: (pk: string, message: string) => Promise<string>;
     nip44Decrypt: (pk: string, message: string) => Promise<string>;
-    teardown: () => void;
 }
 export declare class Nip46Signer implements ISigner {
-    #private;
-    private broker;
+    broker: Nip46Broker;
+    pubkey?: string;
     constructor(broker: Nip46Broker);
     getPubkey: () => Promise<string>;
     sign: (template: StampedEvent) => Promise<any>;

package/build/src/signers/nip46.mjs

@@ -1,230 +1,293 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Nip46Broker_signer, _Nip46Broker_handler, _Nip46Broker_algorithm, _Nip46Broker_closed, _Nip46Broker_processing, _Nip46Broker_connectResponse, _Nip46Broker_queue, _Nip46Broker_window, _Nip46Broker_sub, _Nip46Broker_subscribe, _Nip46Broker_processQueue, _Nip46Broker_getResult, _Nip46Signer_pubkey;
-import { Emitter, sleep, tryCatch, randomId, equals } from "@welshman/lib";
-import { createEvent, NOSTR_CONNECT } from "@welshman/util";
+import { Emitter, throttle, makePromise, defer, sleep, tryCatch, randomId, equals } from "@welshman/lib";
+import { createEvent, normalizeRelayUrl, NOSTR_CONNECT } from "@welshman/util";
 import { subscribe, publish, SubscriptionEvent } from "@welshman/net";
-import { decrypt, hash, own, makeSecret, getPubkey } from "../util.mjs";
+import { decrypt, hash, own } from "../util.mjs";
 import { Nip01Signer } from "./nip01.mjs";
+export var Nip46Event;
+(function (Nip46Event) {
+    Nip46Event["Send"] = "send";
+    Nip46Event["Receive"] = "receive";
+})(Nip46Event || (Nip46Event = {}));
 let singleton;
-export class Nip46Broker extends Emitter {
-    static initiate({ url, name, image, perms, relays, abortController }) {
-        const secret = Math.random().toString(36).substring(7);
-        const clientSecret = makeSecret();
-        const clientPubkey = getPubkey(clientSecret);
-        const clientSigner = new Nip01Signer(clientSecret);
-        const params = new URLSearchParams({ secret, url, name, image, perms });
-        for (const relay of relays) {
-            params.append('relay', relay);
+const popupManager = (() => {
+    let pendingUrl = "";
+    let pendingSince = 0;
+    let currentWindow;
+    const openPending = throttle(1000, () => {
+        // If it's been a while since they asked for it, drop the request
+        if (Date.now() - pendingSince > 10000)
+            return;
+        // If we have an active, open window, continue to wait
+        if (currentWindow && !currentWindow.closed) {
+            setTimeout(() => openPending(), 100);
         }
-        const nostrconnect = `nostrconnect://${clientPubkey}?${params.toString()}`;
-        const result = new Promise(resolve => {
-            const complete = (pubkey) => {
-                sub.close();
-                resolve(pubkey);
-            };
-            const sub = subscribe({
-                relays,
-                filters: [{ kinds: [NOSTR_CONNECT], "#p": [clientPubkey] }],
-                onEvent: async ({ pubkey, content }) => {
-                    const response = await tryCatch(async () => JSON.parse(await decrypt(clientSigner, pubkey, content)));
-                    if ((response === null || response === void 0 ? void 0 : response.result) === secret) {
-                        complete(pubkey);
-                    }
-                    if ((response === null || response === void 0 ? void 0 : response.result) === 'ack') {
-                        console.warn("Bunker responded to nostrconnect with 'ack', which can lead to session hijacking");
-                        complete(pubkey);
-                    }
-                },
-            });
-            abortController === null || abortController === void 0 ? void 0 : abortController.signal.addEventListener('abort', () => complete());
-        });
-        return { result, params, nostrconnect, clientSecret, clientPubkey };
-    }
-    static parseBunkerLink(link) {
-        let token = "";
-        let pubkey = "";
-        let relays = [];
-        try {
-            const url = new URL(link);
-            pubkey = url.hostname || url.pathname.replace(/\//g, '');
-            relays = url.searchParams.getAll("relay") || [];
-            token = url.searchParams.get("secret") || "";
-        }
-        catch (_a) {
-            // pass
-        }
-        return { token, pubkey, relays };
-    }
-    static get(params) {
-        if (!(singleton === null || singleton === void 0 ? void 0 : singleton.hasParams(params))) {
-            singleton === null || singleton === void 0 ? void 0 : singleton.teardown();
-            singleton = new Nip46Broker(params);
+        else {
+            // Attempt to open the window
+            const w = window.open(pendingUrl, "", "width=600,height=800,popup=yes");
+            // If open was successful, keep track of our window
+            if (w) {
+                currentWindow = w;
+            }
+            // In any case, this url has been handled
+            pendingUrl = "";
+            pendingSince = 0;
         }
-        return singleton;
-    }
-    constructor(params) {
+    });
+    return {
+        open: (url) => {
+            pendingUrl = url;
+            pendingSince = Date.now();
+            openPending();
+        },
+    };
+})();
+export class Nip46Receiver extends Emitter {
+    constructor(signer, params) {
         super();
+        this.signer = signer;
         this.params = params;
-        _Nip46Broker_signer.set(this, void 0);
-        _Nip46Broker_handler.set(this, void 0);
-        _Nip46Broker_algorithm.set(this, void 0);
-        _Nip46Broker_closed.set(this, false);
-        _Nip46Broker_processing.set(this, false);
-        _Nip46Broker_connectResponse.set(this, void 0);
-        _Nip46Broker_queue.set(this, []);
-        _Nip46Broker_window.set(this, void 0);
-        _Nip46Broker_sub.set(this, void 0);
-        _Nip46Broker_subscribe.set(this, async () => {
-            const pubkey = await __classPrivateFieldGet(this, _Nip46Broker_signer, "f").getPubkey();
+        this.start = async () => {
+            if (this.sub)
+                return;
+            const userPubkey = await this.signer.getPubkey();
+            const filters = [{ kinds: [NOSTR_CONNECT], "#p": [userPubkey] }];
+            this.sub = subscribe({ relays: this.params.relays, filters });
             return new Promise(resolve => {
-                if (__classPrivateFieldGet(this, _Nip46Broker_sub, "f")) {
-                    __classPrivateFieldGet(this, _Nip46Broker_sub, "f").close();
-                }
-                __classPrivateFieldSet(this, _Nip46Broker_sub, subscribe({
-                    relays: __classPrivateFieldGet(this, _Nip46Broker_handler, "f").relays,
-                    filters: [{ kinds: [NOSTR_CONNECT], "#p": [pubkey] }],
-                }), "f");
-                __classPrivateFieldGet(this, _Nip46Broker_sub, "f").emitter.on(SubscriptionEvent.Send, resolve);
-                __classPrivateFieldGet(this, _Nip46Broker_sub, "f").emitter.on(SubscriptionEvent.Event, async (url, event) => {
-                    const json = await decrypt(__classPrivateFieldGet(this, _Nip46Broker_signer, "f"), event.pubkey, event.content);
+                this.sub.emitter.on(SubscriptionEvent.Send, resolve);
+                this.sub.emitter.on(SubscriptionEvent.Event, async (url, event) => {
+                    const json = await decrypt(this.signer, event.pubkey, event.content);
                     const response = tryCatch(() => JSON.parse(json)) || {};
-                    if (!response.id) {
-                        console.error(`Invalid nostr-connect response: ${json}`);
-                    }
                     // Delay errors in case there's a zombie signer out there clogging things up
                     if (response.error) {
                         await sleep(3000);
                     }
-                    if (response.result === "auth_url") {
-                        this.emit(`auth-${response.id}`, response);
-                    }
-                    else {
-                        this.emit(`res-${response.id}`, response);
-                    }
+                    this.emit(Nip46Event.Receive, { ...response, url, event });
                 });
-                __classPrivateFieldGet(this, _Nip46Broker_sub, "f").emitter.on("complete", () => {
-                    __classPrivateFieldSet(this, _Nip46Broker_sub, undefined, "f");
+                this.sub.emitter.on(SubscriptionEvent.Complete, () => {
+                    this.sub = undefined;
                 });
             });
-        });
-        _Nip46Broker_processQueue.set(this, async () => {
-            if (__classPrivateFieldGet(this, _Nip46Broker_processing, "f")) {
+        };
+        this.stop = () => {
+            var _a;
+            (_a = this.sub) === null || _a === void 0 ? void 0 : _a.close();
+            this.removeAllListeners();
+        };
+    }
+}
+export class Nip46Sender extends Emitter {
+    constructor(signer, params) {
+        super();
+        this.signer = signer;
+        this.params = params;
+        this.processing = false;
+        this.queue = [];
+        this.send = async (request) => {
+            const { id, method, params } = request;
+            const { relays, signerPubkey, algorithm = "nip44" } = this.params;
+            if (!signerPubkey) {
+                throw new Error("Unable to send nip46 request without a signer pubkey");
+            }
+            const payload = JSON.stringify({ id, method, params });
+            const content = await this.signer[algorithm].encrypt(signerPubkey, payload);
+            const template = createEvent(NOSTR_CONNECT, { content, tags: [["p", signerPubkey]] });
+            const event = await this.signer.sign(template);
+            const pub = publish({ relays, event });
+            this.emit(Nip46Event.Send, { ...request, pub });
+        };
+        this.process = async () => {
+            if (this.processing) {
                 return;
             }
-            __classPrivateFieldSet(this, _Nip46Broker_processing, true, "f");
+            this.processing = true;
             try {
-                while (__classPrivateFieldGet(this, _Nip46Broker_queue, "f").length > 0) {
-                    const [{ method, params, resolve }] = __classPrivateFieldGet(this, _Nip46Broker_queue, "f").splice(0, 1);
+                while (this.queue.length > 0) {
+                    const [request] = this.queue.splice(0, 1);
                     try {
-                        const response = await this.request(method, params);
-                        console.log('nip46 response:', { method, params, ...response });
-                        resolve(response);
+                        await this.send(request);
                     }
                     catch (error) {
-                        console.error(`nip46 error:`, { method, params, ...error });
+                        console.error(`nip46 error:`, error, request);
                     }
                 }
             }
             finally {
-                __classPrivateFieldSet(this, _Nip46Broker_processing, false, "f");
-            }
-        });
-        _Nip46Broker_getResult.set(this, async (promise) => {
-            const { result } = await promise;
-            return result;
-        });
-        this.request = async (method, params) => {
-            if (__classPrivateFieldGet(this, _Nip46Broker_closed, "f")) {
-                throw new Error("Attempted to make a nip46 request with a closed broker");
-            }
-            if (!__classPrivateFieldGet(this, _Nip46Broker_sub, "f")) {
-                await __classPrivateFieldGet(this, _Nip46Broker_subscribe, "f").call(this);
+                this.processing = false;
             }
-            const id = randomId();
-            const recipient = __classPrivateFieldGet(this, _Nip46Broker_handler, "f").pubkey;
-            const payload = JSON.stringify({ id, method, params });
-            const content = await __classPrivateFieldGet(this, _Nip46Broker_signer, "f")[__classPrivateFieldGet(this, _Nip46Broker_algorithm, "f")].encrypt(recipient, payload);
-            const template = createEvent(NOSTR_CONNECT, { content, tags: [["p", recipient]] });
-            console.log('nip46 request:', { id, method, params });
-            publish({
-                relays: __classPrivateFieldGet(this, _Nip46Broker_handler, "f").relays,
-                event: await __classPrivateFieldGet(this, _Nip46Broker_signer, "f").sign(template),
-            });
-            this.once(`auth-${id}`, response => {
-                if (!__classPrivateFieldGet(this, _Nip46Broker_window, "f") || __classPrivateFieldGet(this, _Nip46Broker_window, "f").closed) {
-                    const w = window.open(response.error, "", "width=600,height=800,popup=yes");
-                    if (w) {
-                        __classPrivateFieldSet(this, _Nip46Broker_window, w, "f");
-                    }
+        };
+        this.enqueue = (request) => {
+            this.queue.push(request);
+            this.process();
+        };
+        this.stop = () => {
+            this.removeAllListeners();
+        };
+    }
+}
+export class Nip46Request {
+    constructor(method, params) {
+        this.method = method;
+        this.params = params;
+        this.id = randomId();
+        this.promise = defer();
+        this.listen = async (receiver) => {
+            await receiver.start();
+            const onReceive = (response) => {
+                if (response.id !== this.id) {
+                    return;
                 }
-            });
-            return new Promise((resolve, reject) => {
-                this.once(`res-${id}`, (response) => {
+                if (response.result === "auth_url") {
+                    popupManager.open(response.error);
+                }
+                else {
                     if (response.error) {
-                        reject(response);
+                        this.promise.reject(response);
                     }
                     else {
-                        resolve(response);
+                        this.promise.resolve(response);
                     }
-                });
+                    receiver.off(Nip46Event.Receive, onReceive);
+                }
+            };
+            receiver.on(Nip46Event.Receive, onReceive);
+        };
+        this.send = async (sender) => {
+            sender.enqueue(this);
+        };
+    }
+}
+export class Nip46Broker extends Emitter {
+    constructor(params) {
+        super();
+        this.params = params;
+        // Getters for helper objects
+        this.makeSigner = () => new Nip01Signer(this.params.clientSecret);
+        this.makeSender = () => {
+            const sender = new Nip46Sender(this.signer, this.params);
+            sender.on(Nip46Event.Send, (data) => {
+                console.log('nip46 send:', data);
             });
+            return sender;
+        };
+        this.makeReceiver = () => {
+            const receiver = new Nip46Receiver(this.signer, this.params);
+            receiver.on(Nip46Event.Receive, (data) => {
+                console.log('nip46 receive:', data);
+            });
+            return receiver;
+        };
+        // Lifecycle methods
+        this.setParams = (params) => {
+            this.params = { ...this.params, ...params };
+            // Stop everything that's stateful
+            this.teardown();
+            // Set it back up again
+            this.sender = this.makeSender();
+            this.receiver = this.makeReceiver();
+        };
+        this.teardown = () => {
+            this.sender.stop();
+            this.receiver.stop();
         };
-        this.enqueue = (method, params) => new Promise(resolve => {
-            __classPrivateFieldGet(this, _Nip46Broker_queue, "f").push({ method, params, resolve });
-            __classPrivateFieldGet(this, _Nip46Broker_processQueue, "f").call(this);
-        });
-        this.createAccount = (username, perms = "") => {
-            if (!__classPrivateFieldGet(this, _Nip46Broker_handler, "f").domain) {
-                throw new Error("Unable to create an account without a handler domain");
+        // General purpose utility methods
+        this.enqueue = async (method, params) => {
+            const request = new Nip46Request(method, params);
+            await request.listen(this.receiver);
+            await request.send(this.sender);
+            return request;
+        };
+        this.send = async (method, params) => {
+            const request = await this.enqueue(method, params);
+            const response = await request.promise;
+            return response.result;
+        };
+        // Methods for initiating a connection
+        this.parseBunkerUrl = (url) => {
+            let connectSecret = "";
+            let signerPubkey = "";
+            let relays = [];
+            try {
+                const _url = new URL(url);
+                relays = _url.searchParams.getAll("relay") || [];
+                signerPubkey = _url.hostname || _url.pathname.replace(/\//g, '');
+                connectSecret = _url.searchParams.get("secret") || "";
             }
-            return __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("create_account", [username, __classPrivateFieldGet(this, _Nip46Broker_handler, "f").domain, "", perms]));
+            catch (_a) {
+                // pass
+            }
+            return { signerPubkey, connectSecret, relays: relays.map(normalizeRelayUrl) };
         };
-        this.connect = async (token = "", perms = "", secret = "") => {
-            if (!__classPrivateFieldGet(this, _Nip46Broker_connectResponse, "f")) {
-                const params = ["", token, perms];
-                __classPrivateFieldSet(this, _Nip46Broker_connectResponse, await this.enqueue("connect", params), "f");
+        this.makeNostrconnectUrl = async (meta = {}) => {
+            const clientPubkey = await this.signer.getPubkey();
+            const secret = Math.random().toString(36).substring(7);
+            const params = new URLSearchParams({ ...meta, secret });
+            for (const relay of this.params.relays) {
+                params.append('relay', relay);
             }
-            return __classPrivateFieldGet(this, _Nip46Broker_connectResponse, "f").result === 'ack';
-        };
-        this.getPublicKey = () => __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("get_public_key", []));
-        this.signEvent = async (event) => JSON.parse(await __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("sign_event", [JSON.stringify(event)])));
-        this.nip04Encrypt = (pk, message) => __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("nip04_encrypt", [pk, message]));
-        this.nip04Decrypt = (pk, message) => __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("nip04_decrypt", [pk, message]));
-        this.nip44Encrypt = (pk, message) => __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("nip44_encrypt", [pk, message]));
-        this.nip44Decrypt = (pk, message) => __classPrivateFieldGet(this, _Nip46Broker_getResult, "f").call(this, this.enqueue("nip44_decrypt", [pk, message]));
-        this.teardown = () => {
-            var _a;
-            __classPrivateFieldSet(this, _Nip46Broker_closed, true, "f");
-            (_a = __classPrivateFieldGet(this, _Nip46Broker_sub, "f")) === null || _a === void 0 ? void 0 : _a.close();
+            return `nostrconnect://${clientPubkey}?${params.toString()}`;
         };
-        __classPrivateFieldSet(this, _Nip46Broker_handler, params.handler, "f");
-        __classPrivateFieldSet(this, _Nip46Broker_algorithm, params.algorithm || 'nip44', "f");
-        __classPrivateFieldSet(this, _Nip46Broker_signer, new Nip01Signer(params.secret), "f");
+        this.waitForNostrconnect = (url, abort) => {
+            const secret = new URL(url).searchParams.get('secret');
+            return makePromise((resolve, reject) => {
+                const onReceive = (response) => {
+                    if (["ack", secret].includes(response.result)) {
+                        this.setParams({ signerPubkey: response.event.pubkey });
+                        if (response.result === 'ack') {
+                            console.warn("Bunker responded to nostrconnect with 'ack', which can lead to session hijacking");
+                        }
+                        resolve(response);
+                    }
+                    else {
+                        reject(response);
+                    }
+                    cleanup();
+                };
+                const cleanup = () => {
+                    this.receiver.off(Nip46Event.Receive, onReceive);
+                };
+                this.receiver.on(Nip46Event.Receive, onReceive);
+                this.receiver.start();
+                abort === null || abort === void 0 ? void 0 : abort.signal.addEventListener('abort', () => {
+                    reject(undefined);
+                    cleanup();
+                });
+            });
+        };
+        // Normal NIP 46 methods
+        this.ping = () => this.send("ping", []);
+        this.getPublicKey = () => this.send("get_public_key", []);
+        this.createAccount = (username, domain, perms = "") => this.send("create_account", [username, domain, "", perms]);
+        this.connect = async (signerPubkey, connectSecret = "", perms = "") => this.send("connect", [signerPubkey, connectSecret, perms]);
+        this.signEvent = async (event) => JSON.parse(await this.send("sign_event", [JSON.stringify(event)]));
+        this.nip04Encrypt = (pk, message) => this.send("nip04_encrypt", [pk, message]);
+        this.nip04Decrypt = (pk, message) => this.send("nip04_decrypt", [pk, message]);
+        this.nip44Encrypt = (pk, message) => this.send("nip44_encrypt", [pk, message]);
+        this.nip44Decrypt = (pk, message) => this.send("nip44_decrypt", [pk, message]);
+        this.signer = this.makeSigner();
+        this.sender = this.makeSender();
+        this.receiver = this.makeReceiver();
+    }
+    // Use a static getter to avoid duplicate connections
+    static get(params) {
+        if (!(singleton === null || singleton === void 0 ? void 0 : singleton.hasParams(params))) {
+            singleton === null || singleton === void 0 ? void 0 : singleton.teardown();
+            singleton = new Nip46Broker(params);
+        }
+        return singleton;
     }
+    // Expose params without exposing params
     hasParams(params) {
         return equals(this.params, params);
     }
 }
-_Nip46Broker_signer = new WeakMap(), _Nip46Broker_handler = new WeakMap(), _Nip46Broker_algorithm = new WeakMap(), _Nip46Broker_closed = new WeakMap(), _Nip46Broker_processing = new WeakMap(), _Nip46Broker_connectResponse = new WeakMap(), _Nip46Broker_queue = new WeakMap(), _Nip46Broker_window = new WeakMap(), _Nip46Broker_sub = new WeakMap(), _Nip46Broker_subscribe = new WeakMap(), _Nip46Broker_processQueue = new WeakMap(), _Nip46Broker_getResult = new WeakMap();
 export class Nip46Signer {
     constructor(broker) {
         this.broker = broker;
-        _Nip46Signer_pubkey.set(this, void 0);
         this.getPubkey = async () => {
-            if (!__classPrivateFieldGet(this, _Nip46Signer_pubkey, "f")) {
-                __classPrivateFieldSet(this, _Nip46Signer_pubkey, await this.broker.getPublicKey(), "f");
+            if (!this.pubkey) {
+                this.pubkey = await this.broker.getPublicKey();
             }
-            return __classPrivateFieldGet(this, _Nip46Signer_pubkey, "f");
+            return this.pubkey;
         };
         this.sign = async (template) => this.broker.signEvent(hash(own(template, await this.getPubkey())));
         this.nip04 = {
@@ -237,5 +300,4 @@ export class Nip46Signer {
         };
     }
 }
-_Nip46Signer_pubkey = new WeakMap();
 //# sourceMappingURL=nip46.mjs.map