applesauce-signers 0.0.0-next-20250128152442

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 hzrd149
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# applesauce-signer
+
+A collection of signer classes for applesauce
+
+See [documentation](https://hzrd149.github.io/applesauce/signers/signers.html)

package/dist/helpers/encryption.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if a string is encrypted with NIP-04 or NIP-44
+ * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
+ */
+export declare function isNIP04(ciphertext: string): boolean;

package/dist/helpers/encryption.js

@@ -0,0 +1,10 @@
+/**
+ * Checks if a string is encrypted with NIP-04 or NIP-44
+ * @see https://github.com/nostr-protocol/nips/pull/1248#issuecomment-2437731316
+ */
+export function isNIP04(ciphertext) {
+    const l = ciphertext.length;
+    if (l < 28)
+        return false;
+    return (ciphertext[l - 28] == "?" && ciphertext[l - 27] == "i" && ciphertext[l - 26] == "v" && ciphertext[l - 25] == "=");
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from "./encryption.js";

package/dist/helpers/index.js

@@ -0,0 +1 @@
+export * from "./encryption.js";

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import debug from "debug";
+export declare const logger: debug.Debugger;

package/dist/logger.js

@@ -0,0 +1,2 @@
+import debug from "debug";
+export const logger = debug("applesauce:signer");

package/dist/nip-07.d.ts

@@ -0,0 +1,20 @@
+import { EventTemplate, NostrEvent } from "nostr-tools";
+export type Nip07Interface = {
+    getPublicKey: () => Promise<string> | string;
+    signEvent: (template: EventTemplate) => Promise<NostrEvent> | NostrEvent;
+    getRelays?: () => Record<string, {
+        read: boolean;
+        write: boolean;
+    }> | Promise<Record<string, {
+        read: boolean;
+        write: boolean;
+    }>>;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+};

package/dist/nip-07.js

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

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

@@ -0,0 +1,43 @@
+import { EventTemplate, VerifiedEvent, verifyEvent } from "nostr-tools";
+import { Nip07Interface } from "../nip-07.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 {
+    /** 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;
+    };
+    nip44: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    };
+    constructor();
+    private onVisibilityChange;
+    private intentRequest;
+    /** Reject the currently pending request */
+    rejectPending(): void;
+    /** Removes any event listeners created */
+    destroy(): void;
+    private checkSupport;
+    getPublicKey(): Promise<string>;
+    signEvent(draft: EventTemplate & {
+        pubkey?: string;
+    }): Promise<VerifiedEvent>;
+    nip04Encrypt(pubkey: string, plaintext: string): Promise<string>;
+    nip04Decrypt(pubkey: string, data: string): Promise<string>;
+    nip44Encrypt(pubkey: string, plaintext: string): Promise<string>;
+    nip44Decrypt(pubkey: string, data: string): Promise<string>;
+    static createGetPublicKeyIntent(): string;
+    static createSignEventIntent(draft: EventTemplate): string;
+    static createNip04EncryptIntent(pubkey: string, plainText: string): string;
+    static createNip04DecryptIntent(pubkey: string, ciphertext: string): string;
+    static createNip44EncryptIntent(pubkey: string, plainText: string): string;
+    static createNip44DecryptIntent(pubkey: string, ciphertext: string): string;
+}

package/dist/signers/amber-clipboard-signer.js

@@ -0,0 +1,145 @@
+import { getEventHash, nip19, verifyEvent } from "nostr-tools";
+import { getPubkeyFromDecodeResult, isHexKey, isHex } from "applesauce-core/helpers";
+import { createDefer } from "applesauce-core/promise";
+/**
+ * A Signer for [amber](https://github.com/greenart7c3/Amber) clipboard API
+ * @see https://github.com/greenart7c3/Amber/blob/master/docs/web-apps.md
+ */
+export class AmberClipboardSigner {
+    /** If the signer is supported on this platform */
+    static SUPPORTED = `navigator` in globalThis &&
+        navigator.userAgent.includes("Android") &&
+        navigator.clipboard &&
+        navigator.clipboard.readText;
+    pendingRequest = null;
+    pubkey;
+    verifyEvent = verifyEvent;
+    nip04;
+    nip44;
+    constructor() {
+        document.addEventListener("visibilitychange", this.onVisibilityChange);
+        this.nip04 = {
+            encrypt: this.nip04Encrypt.bind(this),
+            decrypt: this.nip04Decrypt.bind(this),
+        };
+        this.nip44 = {
+            encrypt: this.nip44Encrypt.bind(this),
+            decrypt: this.nip44Decrypt.bind(this),
+        };
+    }
+    onVisibilityChange = () => {
+        if (document.visibilityState === "visible") {
+            if (!this.pendingRequest || !navigator.clipboard)
+                return;
+            // read the result from the clipboard
+            setTimeout(() => {
+                navigator.clipboard
+                    .readText()
+                    .then((result) => this.pendingRequest?.resolve(result))
+                    .catch((e) => this.pendingRequest?.reject(e));
+            }, 200);
+        }
+    };
+    async intentRequest(intent) {
+        this.rejectPending();
+        const request = createDefer();
+        window.open(intent, "_blank");
+        // NOTE: wait 500ms before setting the pending request since the visibilitychange event fires as soon as window.open is called
+        setTimeout(() => {
+            this.pendingRequest = request;
+        }, 500);
+        const result = await request;
+        if (result.length === 0)
+            throw new Error("Empty clipboard");
+        return result;
+    }
+    /** Reject the currently pending request */
+    rejectPending() {
+        if (this.pendingRequest) {
+            this.pendingRequest.reject("Canceled");
+            this.pendingRequest = null;
+        }
+    }
+    /** Removes any event listeners created */
+    destroy() {
+        document.removeEventListener("visibilitychange", this.onVisibilityChange);
+    }
+    checkSupport() {
+        if (!AmberClipboardSigner.SUPPORTED)
+            throw new Error("Cant use Amber on non-Android device");
+    }
+    async getPublicKey() {
+        this.checkSupport();
+        if (this.pubkey)
+            return this.pubkey;
+        const result = await this.intentRequest(AmberClipboardSigner.createGetPublicKeyIntent());
+        if (isHexKey(result)) {
+            this.pubkey = result;
+            return result;
+        }
+        else if (result.startsWith("npub") || result.startsWith("nprofile")) {
+            const decode = nip19.decode(result);
+            const pubkey = getPubkeyFromDecodeResult(decode);
+            if (!pubkey)
+                throw new Error("Expected npub from clipboard");
+            this.pubkey = pubkey;
+            return pubkey;
+        }
+        throw new Error("Expected clipboard to have pubkey");
+    }
+    async signEvent(draft) {
+        this.checkSupport();
+        const pubkey = draft.pubkey || this.pubkey;
+        if (!pubkey)
+            throw new Error("Unknown signer pubkey");
+        const draftWithId = { ...draft, id: getEventHash({ ...draft, pubkey }) };
+        const sig = await this.intentRequest(AmberClipboardSigner.createSignEventIntent(draftWithId));
+        if (!isHex(sig))
+            throw new Error("Expected hex signature");
+        const event = { ...draftWithId, sig, pubkey };
+        if (!this.verifyEvent(event))
+            throw new Error("Invalid signature");
+        return event;
+    }
+    // NIP-04
+    async nip04Encrypt(pubkey, plaintext) {
+        this.checkSupport();
+        const data = await this.intentRequest(AmberClipboardSigner.createNip04EncryptIntent(pubkey, plaintext));
+        return data;
+    }
+    async nip04Decrypt(pubkey, data) {
+        this.checkSupport();
+        const plaintext = await this.intentRequest(AmberClipboardSigner.createNip04DecryptIntent(pubkey, data));
+        return plaintext;
+    }
+    // NIP-44
+    async nip44Encrypt(pubkey, plaintext) {
+        this.checkSupport();
+        const data = await this.intentRequest(AmberClipboardSigner.createNip44EncryptIntent(pubkey, plaintext));
+        return data;
+    }
+    async nip44Decrypt(pubkey, data) {
+        this.checkSupport();
+        const plaintext = await this.intentRequest(AmberClipboardSigner.createNip44DecryptIntent(pubkey, data));
+        return plaintext;
+    }
+    // static methods
+    static createGetPublicKeyIntent() {
+        return `intent:#Intent;scheme=nostrsigner;S.compressionType=none;S.returnType=signature;S.type=get_public_key;end`;
+    }
+    static createSignEventIntent(draft) {
+        return `intent:${encodeURIComponent(JSON.stringify(draft))}#Intent;scheme=nostrsigner;S.compressionType=none;S.returnType=signature;S.type=sign_event;end`;
+    }
+    static createNip04EncryptIntent(pubkey, plainText) {
+        return `intent:${encodeURIComponent(plainText)}#Intent;scheme=nostrsigner;S.pubKey=${pubkey};S.compressionType=none;S.returnType=signature;S.type=nip04_encrypt;end`;
+    }
+    static createNip04DecryptIntent(pubkey, ciphertext) {
+        return `intent:${encodeURIComponent(ciphertext)}#Intent;scheme=nostrsigner;S.pubKey=${pubkey};S.compressionType=none;S.returnType=signature;S.type=nip04_decrypt;end`;
+    }
+    static createNip44EncryptIntent(pubkey, plainText) {
+        return `intent:${encodeURIComponent(plainText)}#Intent;scheme=nostrsigner;S.pubKey=${pubkey};S.compressionType=none;S.returnType=signature;S.type=nip44_encrypt;end`;
+    }
+    static createNip44DecryptIntent(pubkey, ciphertext) {
+        return `intent:${encodeURIComponent(ciphertext)}#Intent;scheme=nostrsigner;S.pubKey=${pubkey};S.compressionType=none;S.returnType=signature;S.type=nip44_decrypt;end`;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { EventTemplate } from "nostr-tools";
+import { Nip07Interface } from "../nip-07.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 {
+    get nip04(): {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    } | undefined;
+    get nip44(): {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | 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>;
+}

package/dist/signers/extension-signer.js

@@ -0,0 +1,29 @@
+/** AN error that is throw when the window.nostr extension is missing */
+export class ExtensionMissingError extends Error {
+}
+/** A signer that is a proxy for window.nostr */
+export class ExtensionSigner {
+    get nip04() {
+        return window.nostr?.nip04;
+    }
+    get nip44() {
+        return window.nostr?.nip44;
+    }
+    getPublicKey() {
+        if (!window.nostr)
+            throw new ExtensionMissingError("Signer extension missing");
+        return window.nostr.getPublicKey();
+    }
+    getRelays() {
+        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);
+    }
+}

package/dist/signers/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./amber-clipboard-signer.js";
+export * from "./extension-signer.js";
+export * from "./nostr-connect-signer.js";
+export * from "./password-signer.js";
+export * from "./readonly-signer.js";
+export * from "./serial-port-signer.js";
+export * from "./simple-signer.js";

package/dist/signers/index.js

@@ -0,0 +1,7 @@
+export * from "./amber-clipboard-signer.js";
+export * from "./extension-signer.js";
+export * from "./nostr-connect-signer.js";
+export * from "./password-signer.js";
+export * from "./readonly-signer.js";
+export * from "./serial-port-signer.js";
+export * from "./simple-signer.js";

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

@@ -0,0 +1,163 @@
+import { EventTemplate, Filter, NostrEvent, verifyEvent } from "nostr-tools";
+import { Nip07Interface, SimpleSigner } from "applesauce-signers";
+import { Deferred } from "applesauce-core/promise";
+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"
+}
+type RequestParams = {
+    [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];
+};
+type ResponseResults = {
+    [NostrConnectMethod.Connect]: "ack";
+    [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: RequestParams[N];
+};
+export type NostrConnectResponse<N extends NostrConnectMethod> = {
+    id: string;
+    result: ResponseResults[N];
+    error?: string;
+};
+export type NostrConnectErrorResponse = {
+    id: string;
+    result: string;
+    error: string;
+};
+export type NostrConnectSignerOptions = {
+    /** The relays to communicate over */
+    relays: string[];
+    /** A {@link SimpleSigner} for this client */
+    signer?: SimpleSigner;
+    /** pubkey of the remote signer application */
+    remote?: string;
+    /** Users pubkey */
+    pubkey?: string;
+};
+export type NostrConnectConnectionMethods = {
+    /** A method that is called when the subscription needs to be updated */
+    onSubOpen: (filters: Filter[], relays: string[], onEvent: (event: NostrEvent) => void) => Promise<void>;
+    /** A method called when the subscription should be closed */
+    onSubClose: () => Promise<void>;
+    /** A method that is called when an event needs to be published */
+    onPublishEvent: (event: NostrEvent, relays: string[]) => Promise<void>;
+    /** A method for handling "auth" requests */
+    onAuth?: (url: string) => Promise<void>;
+};
+export type NostrConnectAppMetadata = {
+    name?: string;
+    image?: string;
+    url?: string | URL;
+    permissions?: string[];
+};
+export declare class NostrConnectSigner implements Nip07Interface {
+    /** A method that is called when the subscription needs to be updated */
+    onSubOpen?: (filters: Filter[], relays: string[], onEvent: (event: NostrEvent) => void) => Promise<void>;
+    /** A method called when the subscription should be closed */
+    onSubClose?: () => Promise<void>;
+    /** A method that is called when an event needs to be published */
+    onPublishEvent?: (event: NostrEvent, relays: string[]) => Promise<void>;
+    protected log: import("debug").Debugger;
+    /** The local client signer */
+    signer: SimpleSigner;
+    protected subscriptionOpen: boolean;
+    /** Whether the signer is connected to the remote signer */
+    isConnected: boolean;
+    /** The users pubkey */
+    protected pubkey?: string;
+    /** Relays to communicate over */
+    relays: string[];
+    /** The remote signer pubkey */
+    remote?: string;
+    /** Client pubkey */
+    get clientPubkey(): string;
+    onAuth: (url: string) => Promise<void>;
+    verifyEvent: typeof verifyEvent;
+    /** A secret used when initiating a connection from the client side */
+    protected clientSecret: string;
+    nip04?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    } | undefined;
+    nip44?: {
+        encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
+        decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
+    } | undefined;
+    constructor(opts: NostrConnectConnectionMethods & NostrConnectSignerOptions);
+    /** Open the connection */
+    open(): Promise<void>;
+    /** Close the connection */
+    close(): Promise<void>;
+    protected requests: Map<string, Deferred<any>>;
+    protected auths: Set<string>;
+    /** Call this method with incoming events */
+    handleEvent(event: NostrEvent): Promise<void>;
+    protected createRequestEvent(content: string, target?: string | undefined, kind?: number): Promise<import("nostr-tools").VerifiedEvent>;
+    private makeRequest;
+    /** Connect to remote signer */
+    connect(secret?: string | undefined, permissions?: string[]): Promise<"ack">;
+    private waitingPromise;
+    /** Wait for a remote signer to connect */
+    waitForSigner(): Promise<void>;
+    /** Request to create an account on the remote signer */
+    createAccount(username: string, domain: string, email?: string, permissions?: string[]): Promise<string>;
+    /** Ensure the signer is connected to the remote signer */
+    requireConnection(): Promise<void>;
+    /** Get the users pubkey */
+    getPublicKey(): Promise<string>;
+    /** Request to sign an event */
+    signEvent(template: EventTemplate & {
+        pubkey?: string;
+    }): Promise<import("nostr-tools").VerifiedEvent>;
+    nip04Encrypt(pubkey: string, plaintext: string): Promise<string>;
+    nip04Decrypt(pubkey: string, ciphertext: string): Promise<string>;
+    nip44Encrypt(pubkey: string, plaintext: string): Promise<string>;
+    nip44Decrypt(pubkey: string, ciphertext: string): Promise<string>;
+    /** Returns the nostrconnect:// URI for this signer */
+    getNostrConnectURI(metadata?: NostrConnectAppMetadata): string;
+    /** Parses a bunker:// URI */
+    static parseBunkerURI(uri: string): {
+        remote: string;
+        relays: string[];
+        secret?: string;
+    };
+    /** Builds an array of signing permissions for event kinds */
+    static buildSigningPermissions(kinds: number[]): string[];
+    /** Create a {@link NostrConnectSigner} from a bunker:// URI */
+    static fromBunkerURI(uri: string, options: NostrConnectConnectionMethods & {
+        permissions?: string[];
+        signer?: SimpleSigner;
+    }): Promise<NostrConnectSigner>;
+}
+export {};