applesauce-signers 2.0.0 → 3.1.0

package/dist/helpers/index.d.ts

@@ -1 +1,2 @@
 export * from "./encryption.js";
+export * from "./nostr-connect.js";

package/dist/helpers/index.js

@@ -1 +1,2 @@
 export * from "./encryption.js";
+export * from "./nostr-connect.js";

package/dist/helpers/nostr-connect.d.ts

@@ -0,0 +1,92 @@
+export declare function isErrorResponse(response: any): response is NostrConnectErrorResponse;
+export declare enum Permission {
+    GetPublicKey = "get_pubic_key",
+    SignEvent = "sign_event",
+    Nip04Encrypt = "nip04_encrypt",
+    Nip04Decrypt = "nip04_decrypt",
+    Nip44Encrypt = "nip44_encrypt",
+    Nip44Decrypt = "nip44_decrypt"
+}
+export declare enum NostrConnectMethod {
+    Connect = "connect",
+    CreateAccount = "create_account",
+    GetPublicKey = "get_public_key",
+    SignEvent = "sign_event",
+    Nip04Encrypt = "nip04_encrypt",
+    Nip04Decrypt = "nip04_decrypt",
+    Nip44Encrypt = "nip44_encrypt",
+    Nip44Decrypt = "nip44_decrypt"
+}
+export type ConnectRequestParams = {
+    [NostrConnectMethod.Connect]: [string] | [string, string] | [string, string, string];
+    [NostrConnectMethod.CreateAccount]: [string, string] | [string, string, string] | [string, string, string, string];
+    [NostrConnectMethod.GetPublicKey]: [];
+    [NostrConnectMethod.SignEvent]: [string];
+    [NostrConnectMethod.Nip04Encrypt]: [string, string];
+    [NostrConnectMethod.Nip04Decrypt]: [string, string];
+    [NostrConnectMethod.Nip44Encrypt]: [string, string];
+    [NostrConnectMethod.Nip44Decrypt]: [string, string];
+};
+export type ConnectResponseResults = {
+    [NostrConnectMethod.Connect]: "ack" | string;
+    [NostrConnectMethod.CreateAccount]: string;
+    [NostrConnectMethod.GetPublicKey]: string;
+    [NostrConnectMethod.SignEvent]: string;
+    [NostrConnectMethod.Nip04Encrypt]: string;
+    [NostrConnectMethod.Nip04Decrypt]: string;
+    [NostrConnectMethod.Nip44Encrypt]: string;
+    [NostrConnectMethod.Nip44Decrypt]: string;
+};
+export type NostrConnectRequest<N extends NostrConnectMethod> = {
+    id: string;
+    method: N;
+    params: ConnectRequestParams[N];
+};
+export type NostrConnectResponse<N extends NostrConnectMethod> = {
+    id: string;
+    result: ConnectResponseResults[N];
+    error?: string;
+};
+export type NostrConnectErrorResponse = {
+    id: string;
+    result: string;
+    error: string;
+};
+/** A bunker:// URI */
+export type BunkerURI = {
+    remote: string;
+    relays: string[];
+    secret?: string;
+};
+/** Parse a bunker:// URI */
+export declare function parseBunkerURI(uri: string): BunkerURI;
+/** Creates a bunker:// URI from a {@link BunkerURI} object */
+export declare function createBunkerURI(data: BunkerURI): string;
+/** App metadata for a nostrconnect:// URI */
+export type NostrConnectAppMetadata = {
+    /** The name of the client */
+    name?: string;
+    /** An image for the client */
+    image?: string;
+    /** The url of the client */
+    url?: string | URL;
+    /** The permissions the client has */
+    permissions?: string[];
+};
+/** A nostrconnect:// URI */
+export type NostrConnectURI = {
+    /** The pubkey of the client */
+    client: string;
+    /** The secret used by the signer to connect to the client */
+    secret: string;
+    /** The relays used to communicate with the remote signer */
+    relays: string[];
+    /** The metadata of the client */
+    metadata?: NostrConnectAppMetadata;
+};
+/** Parse a nostrconnect:// URI */
+export declare function parseNostrConnectURI(uri: string): NostrConnectURI;
+/** Create a nostrconnect:// URI from a {@link NostrConnectURI} object */
+export declare function createNostrConnectURI(data: NostrConnectURI): string;
+/** Build an array of signing permissions for event kinds */
+export declare function buildSigningPermissions(kinds: number[]): string[];

package/dist/helpers/nostr-connect.js

@@ -0,0 +1,93 @@
+import { setHiddenContentEncryptionMethod } from "applesauce-core/helpers";
+import { isHexKey } from "applesauce-core/helpers/string";
+import { kinds } from "nostr-tools";
+// Set encryption types for nostr connect events
+setHiddenContentEncryptionMethod(kinds.NostrConnect, "nip44");
+export function isErrorResponse(response) {
+    return !!response.error;
+}
+export var Permission;
+(function (Permission) {
+    Permission["GetPublicKey"] = "get_pubic_key";
+    Permission["SignEvent"] = "sign_event";
+    Permission["Nip04Encrypt"] = "nip04_encrypt";
+    Permission["Nip04Decrypt"] = "nip04_decrypt";
+    Permission["Nip44Encrypt"] = "nip44_encrypt";
+    Permission["Nip44Decrypt"] = "nip44_decrypt";
+})(Permission || (Permission = {}));
+export var NostrConnectMethod;
+(function (NostrConnectMethod) {
+    NostrConnectMethod["Connect"] = "connect";
+    NostrConnectMethod["CreateAccount"] = "create_account";
+    NostrConnectMethod["GetPublicKey"] = "get_public_key";
+    NostrConnectMethod["SignEvent"] = "sign_event";
+    NostrConnectMethod["Nip04Encrypt"] = "nip04_encrypt";
+    NostrConnectMethod["Nip04Decrypt"] = "nip04_decrypt";
+    NostrConnectMethod["Nip44Encrypt"] = "nip44_encrypt";
+    NostrConnectMethod["Nip44Decrypt"] = "nip44_decrypt";
+})(NostrConnectMethod || (NostrConnectMethod = {}));
+/** Parse a bunker:// URI */
+export function parseBunkerURI(uri) {
+    const url = new URL(uri);
+    // firefox puts pubkey part in host, chrome puts pubkey in pathname
+    const remote = url.host || url.pathname.replace("//", "");
+    if (!isHexKey(remote))
+        throw new Error("Invalid bunker URI: remote is not a valid hex key");
+    const relays = url.searchParams.getAll("relay");
+    if (relays.length === 0)
+        throw new Error("Invalid bunker URI: missing relays");
+    const secret = url.searchParams.get("secret") ?? undefined;
+    return { remote, relays, secret };
+}
+/** Creates a bunker:// URI from a {@link BunkerURI} object */
+export function createBunkerURI(data) {
+    const url = new URL(`bunker://${data.remote}`);
+    data.relays.forEach((relay) => url.searchParams.append("relay", relay));
+    if (data.secret)
+        url.searchParams.set("secret", data.secret);
+    return url.toString();
+}
+/** Parse a nostrconnect:// URI */
+export function parseNostrConnectURI(uri) {
+    const url = new URL(uri);
+    const client = url.host || url.pathname.replace("//", "");
+    if (!isHexKey(client))
+        throw new Error("Invalid nostrconnect URI: client is not a valid hex key");
+    const secret = url.searchParams.get("secret");
+    const relays = url.searchParams.getAll("relay");
+    if (!secret)
+        throw new Error("Invalid nostrconnect URI: missing secret");
+    if (relays.length === 0)
+        throw new Error("Invalid nostrconnect URI: missing relays");
+    const metadata = {
+        name: url.searchParams.get("name") ?? undefined,
+        image: url.searchParams.get("image") ?? undefined,
+        url: url.searchParams.get("url") ?? undefined,
+        permissions: url.searchParams.get("perms")?.split(",") ?? undefined,
+    };
+    /** Omit metadata if all values are undefined */
+    if (Object.values(metadata).every((v) => v === undefined))
+        return { client, secret, relays };
+    else
+        return { client, secret, relays, metadata };
+}
+/** Create a nostrconnect:// URI from a {@link NostrConnectURI} object */
+export function createNostrConnectURI(data) {
+    const params = new URLSearchParams();
+    params.set("secret", data.secret);
+    if (data.metadata?.name)
+        params.set("name", data.metadata.name);
+    if (data.metadata?.url)
+        params.set("url", String(data.metadata.url));
+    if (data.metadata?.image)
+        params.set("image", data.metadata.image);
+    if (data.metadata?.permissions)
+        params.set("perms", data.metadata.permissions.join(","));
+    for (const relay of data.relays)
+        params.append("relay", relay);
+    return `nostrconnect://${data.client}?` + params.toString();
+}
+/** Build an array of signing permissions for event kinds */
+export function buildSigningPermissions(kinds) {
+    return [Permission.GetPublicKey, ...kinds.map((k) => `${Permission.SignEvent}:${k}`)];
+}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./nip-07.js";
+export * from "./interop.js";
 export * from "./signers/index.js";
 export * as Helpers from "./helpers/index.js";

package/dist/index.js

@@ -1,3 +1,3 @@
-export * from "./nip-07.js";
+export * from "./interop.js";
 export * from "./signers/index.js";
 export * as Helpers from "./helpers/index.js";

package/dist/interop.d.ts

@@ -0,0 +1,49 @@
+import { EventTemplate, Filter, NostrEvent } from "nostr-tools";
+import { ObservableInput } from "rxjs";
+export type ISigner = {
+    getPublicKey: () => Promise<string>;
+    signEvent: (template: EventTemplate) => Promise<NostrEvent>;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
+    };
+};
+/** @deprecated Use ISigner instead */
+export type Nip07Interface = ISigner;
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => ObservableInput<NostrEvent | string>;
+/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
+export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | ObservableInput<any>;
+/** A simple pool type that combines the subscription and publish methods */
+export type NostrPool = {
+    subscription: NostrSubscriptionMethod;
+    publish: NostrPublishMethod;
+};
+/** Options for setting the subscription and publish methods */
+export type NostrConnectionMethodsOptions = {
+    /** An optional method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** An optional method for publishing events */
+    publishMethod?: NostrPublishMethod;
+    /** An optional pool for connection methods */
+    pool?: NostrPool;
+};
+/** A class that implements has global fallback methods for subscription and publish methods */
+export interface NostrConnectionClassMethods {
+    new (...args: any[]): any;
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    publishMethod: NostrPublishMethod | undefined;
+    /** A fallback pool to use if none is pass in when creating the signer */
+    pool: NostrPool | undefined;
+}
+/** Get the subscription and publish methods for a NostrConnect class */
+export declare function getConnectionMethods(options: NostrConnectionMethodsOptions, cls?: NostrConnectionClassMethods): {
+    subscriptionMethod: NostrSubscriptionMethod;
+    publishMethod: NostrPublishMethod;
+};

package/dist/interop.js

@@ -0,0 +1,19 @@
+/** Get the subscription and publish methods for a NostrConnect class */
+export function getConnectionMethods(options, cls) {
+    const subscriptionMethod = options.subscriptionMethod ||
+        options.pool?.subscription.bind(options.pool) ||
+        cls?.subscriptionMethod ||
+        cls?.pool?.subscription.bind(cls.pool);
+    if (!subscriptionMethod)
+        throw new Error("Missing subscriptionMethod, either pass a method or set subscriptionMethod globally on the class");
+    const publishMethod = options.publishMethod ||
+        options.pool?.publish.bind(options.pool) ||
+        cls?.publishMethod ||
+        cls?.pool?.publish.bind(cls.pool);
+    if (!publishMethod)
+        throw new Error("Missing publishMethod, either pass a method or set publishMethod globally on the class");
+    return {
+        subscriptionMethod,
+        publishMethod,
+    };
+}

package/dist/signers/amber-clipboard-signer.d.ts

@@ -1,22 +1,22 @@
 import { EventTemplate, VerifiedEvent, verifyEvent } from "nostr-tools";
-import { Nip07Interface } from "../nip-07.js";
+import { ISigner } from "../interop.js";
 /**
  * A Signer for [amber](https://github.com/greenart7c3/Amber) clipboard API
  * @see https://github.com/greenart7c3/Amber/blob/master/docs/web-apps.md
  */
-export declare class AmberClipboardSigner implements Nip07Interface {
+export declare class AmberClipboardSigner implements ISigner {
     /** If the signer is supported on this platform */
     static SUPPORTED: false | (() => Promise<string>);
     private pendingRequest;
     pubkey?: string;
     verifyEvent: typeof verifyEvent;
     nip04: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     nip44: {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     };
     constructor();
     private onVisibilityChange;

package/dist/signers/extension-signer.d.ts

@@ -1,26 +1,19 @@
-import { EventTemplate } from "nostr-tools";
-import { Nip07Interface } from "../nip-07.js";
+import { EventTemplate, VerifiedEvent } from "nostr-tools";
+import { ISigner } from "../interop.js";
 /** AN error that is throw when the window.nostr extension is missing */
 export declare class ExtensionMissingError extends Error {
 }
 /** A signer that is a proxy for window.nostr */
-export declare class ExtensionSigner implements Nip07Interface {
+export declare class ExtensionSigner implements ISigner {
     get nip04(): {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     } | undefined;
     get nip44(): {
-        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+        encrypt: (pubkey: string, plaintext: string) => Promise<string>;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string>;
     } | undefined;
     protected pubkey: string | undefined;
-    getPublicKey(): string | Promise<string>;
-    getRelays(): Record<string, {
-        read: boolean;
-        write: boolean;
-    }> | Promise<Record<string, {
-        read: boolean;
-        write: boolean;
-    }>>;
-    signEvent(template: EventTemplate): import("nostr-tools").Event | Promise<import("nostr-tools").Event>;
+    getPublicKey(): Promise<string>;
+    signEvent(template: EventTemplate): Promise<VerifiedEvent>;
 }

package/dist/signers/extension-signer.js

@@ -1,3 +1,4 @@
+import { verifyEvent } from "nostr-tools";
 /** AN error that is throw when the window.nostr extension is missing */
 export class ExtensionMissingError extends Error {
 }
@@ -10,32 +11,20 @@ export class ExtensionSigner {
         return window.nostr?.nip44;
     }
     pubkey = undefined;
-    getPublicKey() {
+    async getPublicKey() {
         if (!window.nostr)
             throw new ExtensionMissingError("Signer extension missing");
         if (this.pubkey)
             return this.pubkey;
-        const p = window.nostr.getPublicKey();
-        if (p instanceof Promise)
-            return p.then((pubkey) => {
-                this.pubkey = pubkey;
-                return pubkey;
-            });
-        else {
-            this.pubkey = p;
-            return p;
-        }
+        this.pubkey = await window.nostr.getPublicKey();
+        return this.pubkey;
     }
-    getRelays() {
+    async signEvent(template) {
         if (!window.nostr)
             throw new ExtensionMissingError("Signer extension missing");
-        if (!window.nostr.getRelays)
-            return {};
-        return window.nostr.getRelays();
-    }
-    signEvent(template) {
-        if (!window.nostr)
-            throw new ExtensionMissingError("Signer extension missing");
-        return window.nostr.signEvent(template);
+        const event = await window.nostr.signEvent(template);
+        if (!verifyEvent(event))
+            throw new Error("Extension returned an invalid event");
+        return event;
     }
 }

package/dist/signers/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./amber-clipboard-signer.js";
 export * from "./extension-signer.js";
+export * from "./nostr-connect-provider.js";
 export * from "./nostr-connect-signer.js";
 export * from "./password-signer.js";
 export * from "./readonly-signer.js";

package/dist/signers/index.js

@@ -1,5 +1,6 @@
 export * from "./amber-clipboard-signer.js";
 export * from "./extension-signer.js";
+export * from "./nostr-connect-provider.js";
 export * from "./nostr-connect-signer.js";
 export * from "./password-signer.js";
 export * from "./readonly-signer.js";

package/dist/signers/nostr-connect-provider.d.ts

@@ -0,0 +1,121 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+import { Subscription } from "rxjs";
+import { ConnectRequestParams, ConnectResponseResults, NostrConnectMethod, NostrConnectResponse, NostrConnectURI } from "../helpers/nostr-connect.js";
+import { ISigner, NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "../interop.js";
+export interface ProviderAuthorization {
+    /** A method used to accept or reject `connect` requests */
+    onConnect?: (client: string, permissions: string[]) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `sign_event` requests */
+    onSignEvent?: (draft: EventTemplate, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip04_encrypt` requests */
+    onNip04Encrypt?: (pubkey: string, plaintext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip04_decrypt` requests */
+    onNip04Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip44_encrypt` requests */
+    onNip44Encrypt?: (pubkey: string, plaintext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip44_decrypt` requests */
+    onNip44Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
+}
+export type NostrConnectProviderOptions = ProviderAuthorization & NostrConnectionMethodsOptions & {
+    /** The relays to communicate over */
+    relays: string[];
+    /** The signer to use for signing events and encryption */
+    upstream: ISigner;
+    /** Optional signer for provider identity */
+    signer?: ISigner;
+    /** A random secret used to authorize clients to connect */
+    secret?: string;
+    /** Callback for when a client connects (receives a `connect` request) */
+    onClientConnect?: (client: string) => any;
+    /** Callback for when a client disconnects (previously connected and the provider stops) */
+    onClientDisconnect?: (client: string) => void;
+};
+export declare class NostrConnectProvider implements ProviderAuthorization {
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the provider */
+    static subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the provider */
+    static publishMethod: NostrPublishMethod | undefined;
+    /** A fallback pool to use if none is pass in when creating the provider */
+    static pool: NostrPool | undefined;
+    /** A method that is called when an event needs to be published */
+    protected publishMethod: NostrPublishMethod;
+    /** The active nostr subscription */
+    protected subscriptionMethod: NostrSubscriptionMethod;
+    /** Internal logger */
+    protected log: import("debug").Debugger;
+    /** A set of nostr requests that have been seen */
+    protected seen: Set<string>;
+    /** The main signer for the actual signing operations */
+    upstream: ISigner;
+    /** The identity signer (provider's identity) */
+    signer: ISigner;
+    /** Whether the provider is listening for events */
+    listening: boolean;
+    /** The connected client's public key */
+    client?: string;
+    /** The secret used to authorize clients to connect */
+    secret?: string;
+    /** Relays to communicate over */
+    readonly relays: string[];
+    /** Whether a client is connected (received a `connect` request) */
+    connected: boolean;
+    /** Callbacks */
+    onClientConnect?: (client: string) => any;
+    onClientDisconnect?: (client: string) => any;
+    /** A method used to accept or reject `connect` requests */
+    onConnect?: (client: string, permissions: string[]) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `sign_event` requests */
+    onSignEvent?: (draft: EventTemplate, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip04_encrypt` requests */
+    onNip04Encrypt?: (pubkey: string, plaintext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip04_decrypt` requests */
+    onNip04Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip44_encrypt` requests */
+    onNip44Encrypt?: (pubkey: string, plaintext: string, client: string) => boolean | Promise<boolean>;
+    /** A method used to accept or reject `nip44_decrypt` requests */
+    onNip44Decrypt?: (pubkey: string, ciphertext: string, client: string) => boolean | Promise<boolean>;
+    constructor(options: NostrConnectProviderOptions);
+    /** The currently active REQ subscription */
+    protected req?: Subscription;
+    /** Updates the relay subscription to listen for request events */
+    protected updateSubscription(): Promise<void>;
+    /**
+     * Start the provider
+     * @param request - An inital `connect` request to respond to or a {@link NostrConnectURI}
+     */
+    start(request?: NostrEvent | NostrConnectURI | string): Promise<void>;
+    /** Stop the provider */
+    stop(): Promise<void>;
+    private waitingPromise;
+    /** Wait for a client to connect */
+    waitForClient(abort?: AbortSignal): Promise<string>;
+    /** Call this method with incoming events */
+    handleEvent(event: NostrEvent): Promise<void>;
+    /** Handle an initial NostrConnectURI */
+    handleNostrConnectURI(uri: NostrConnectURI | string): Promise<void>;
+    /** Handle connect request */
+    protected handleConnect(client: string, [target, secret, permissionsStr]: ConnectRequestParams[NostrConnectMethod.Connect]): Promise<ConnectResponseResults[NostrConnectMethod.Connect]>;
+    /** Handle sign event request */
+    protected handleSignEvent([eventJson]: ConnectRequestParams[NostrConnectMethod.SignEvent]): Promise<ConnectResponseResults[NostrConnectMethod.SignEvent]>;
+    /** Handle NIP-04 encryption */
+    protected handleNip04Encrypt([pubkey, plaintext,]: ConnectRequestParams[NostrConnectMethod.Nip04Encrypt]): Promise<ConnectResponseResults[NostrConnectMethod.Nip04Encrypt]>;
+    /** Handle NIP-04 decryption */
+    protected handleNip04Decrypt([pubkey, ciphertext,]: ConnectRequestParams[NostrConnectMethod.Nip04Decrypt]): Promise<ConnectResponseResults[NostrConnectMethod.Nip04Decrypt]>;
+    /** Handle NIP-44 encryption */
+    protected handleNip44Encrypt([pubkey, plaintext,]: ConnectRequestParams[NostrConnectMethod.Nip44Encrypt]): Promise<ConnectResponseResults[NostrConnectMethod.Nip44Encrypt]>;
+    /** Handle NIP-44 decryption */
+    protected handleNip44Decrypt([pubkey, ciphertext,]: ConnectRequestParams[NostrConnectMethod.Nip44Decrypt]): Promise<ConnectResponseResults[NostrConnectMethod.Nip44Decrypt]>;
+    /**
+     * Send a response to the client
+     * @param clientOrRequest - The client pubkey or request event
+     * @param requestId - The id of the request
+     * @param result - The result of the request
+     */
+    protected sendResponse<T extends NostrConnectMethod>(clientOrRequest: NostrEvent | string, requestId: string, result: ConnectResponseResults[T]): Promise<void>;
+    /** Send an error response to the client */
+    protected sendErrorResponse(event: NostrEvent, requestId: string, error: string): Promise<void>;
+    /** Send an encrypted message to the client */
+    protected sendMessage(clientOrRequest: string | NostrEvent, message: NostrConnectResponse<any>): Promise<void>;
+    /** Get the connection string that clients can use to connect */
+    getBunkerURI(): Promise<string>;
+}