applesauce-wallet-connect 0.0.0-next-20250808173123

package/dist/operations/wallet.js

@@ -0,0 +1,30 @@
+import { bytesToHex } from "@noble/hashes/utils";
+import { modifyHiddenTags } from "applesauce-factory/operations";
+import { setSingletonTag } from "applesauce-factory/operations/tag";
+import { WALLET_KIND } from "../helpers/wallet.js";
+/** Sets the content of a kind 375 wallet backup event */
+export function setBackupContent(wallet) {
+    return async (draft, ctx) => {
+        if (wallet.kind !== WALLET_KIND)
+            throw new Error(`Cant create a wallet backup from kind ${wallet.kind}`);
+        if (!wallet.content)
+            throw new Error("Wallet missing content");
+        const pubkey = await ctx.signer?.getPublicKey();
+        if (wallet.pubkey !== pubkey)
+            throw new Error("Wallet pubkey dose not match signer pubkey");
+        return { ...draft, content: wallet.content };
+    };
+}
+/** Sets the "mint" tags in a wallet event */
+export function setMints(mints) {
+    return modifyHiddenTags((tags) => [
+        // remove all existing mint tags
+        ...tags.filter((t) => t[0] !== "mint"),
+        // add new mint tags
+        ...mints.map((mint) => ["mint", mint]),
+    ]);
+}
+/** Sets the "privkey" tag on a wallet event */
+export function setPrivateKey(privateKey) {
+    return modifyHiddenTags(setSingletonTag(["privkey", bytesToHex(privateKey)], true));
+}

package/dist/operations/zap-info.d.ts

@@ -0,0 +1,10 @@
+import { EventOperation } from "applesauce-factory";
+/** Sets the relays for a nutzap info event */
+export declare function setNutzapInfoRelays(relays: string[]): EventOperation;
+/** Sets the mints for a nutzap info event */
+export declare function setNutzapInfoMints(mints: Array<{
+    url: string;
+    units?: string[];
+}>): EventOperation;
+/** Sets the pubkey for a nutzap info event */
+export declare function setNutzapInfoPubkey(pubkey: string): EventOperation;

package/dist/operations/zap-info.js

@@ -0,0 +1,17 @@
+import { modifyPublicTags } from "applesauce-factory/operations";
+import { addNameValueTag, setSingletonTag } from "applesauce-factory/operations/tag";
+/** Sets the relays for a nutzap info event */
+export function setNutzapInfoRelays(relays) {
+    return modifyPublicTags(...relays.map((relay) => addNameValueTag(["relay", relay], false)));
+}
+/** Sets the mints for a nutzap info event */
+export function setNutzapInfoMints(mints) {
+    return modifyPublicTags(...mints.map((mint) => {
+        const tag = mint.units ? ["mint", mint.url, ...mint.units] : ["mint", mint.url];
+        return addNameValueTag(tag, false);
+    }));
+}
+/** Sets the pubkey for a nutzap info event */
+export function setNutzapInfoPubkey(pubkey) {
+    return modifyPublicTags(setSingletonTag(["pubkey", pubkey], true));
+}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Observable } from "rxjs";
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Observable<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> | Observable<any>;

package/dist/types.js

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

package/dist/wallet-connect.d.ts

@@ -0,0 +1,111 @@
+import { EventSigner } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+import { Observable, Subscription } from "rxjs";
+import { EncryptionMethod } from "applesauce-core/helpers";
+import { GetBalanceResult, GetInfoResult, ListTransactionsResult, LookupInvoiceResult, MakeInvoiceParams, MakeInvoiceResult, NotificationType, PayInvoiceResult, PayKeysendResult, WalletConnectEncryptionMethod, WalletConnectURI, WalletMethod, WalletNotification, WalletRequest, WalletResponse, WalletSupport } from "./helpers/index.js";
+import { NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
+export type SerializedWalletConnect = WalletConnectURI;
+export type WalletConnectOptions = {
+    /** A method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** A method for publishing events */
+    publishMethod?: NostrPublishMethod;
+    /** Default timeout for RPC requests in milliseconds */
+    timeout?: number;
+};
+export declare class WalletConnect {
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    static subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    static publishMethod: NostrPublishMethod | undefined;
+    /** A method that is called when an event needs to be published */
+    protected publishMethod: NostrPublishMethod;
+    /** The active nostr subscription method */
+    protected subscriptionMethod: NostrSubscriptionMethod;
+    /** The local client signer */
+    readonly secret: Uint8Array;
+    protected readonly signer: EventSigner;
+    /** The relays to use for the connection */
+    readonly relays: string[];
+    /** The wallet service public key */
+    readonly service: string;
+    /** Default timeout for requests */
+    defaultTimeout: number;
+    /** Observable for wallet info updates */
+    support$: Observable<WalletSupport | null>;
+    /** The preferred encryption method for the wallet */
+    encryption$: Observable<WalletConnectEncryptionMethod>;
+    /** Shared observable for all wallet response events and notifications */
+    protected events$: Observable<NostrEvent>;
+    /** Shared observable for all wallet notifications */
+    notifications$: Observable<WalletNotification>;
+    constructor(secret: Uint8Array, service: string, relays: string[], options?: WalletConnectOptions);
+    /** Process response events and return WalletResponse or throw error */
+    protected handleResponseEvent(event: NostrEvent, encryption?: EncryptionMethod): Promise<WalletResponse>;
+    /** Handle notification events */
+    protected handleNotificationEvent(event: NostrEvent): Promise<WalletNotification>;
+    /** Core RPC method that makes a request and returns the response */
+    request(request: WalletRequest, options?: {
+        timeout?: number;
+    }): Observable<WalletResponse>;
+    /**
+     * Listen for a type of notification
+     * @returns a method to unsubscribe the listener
+     */
+    notification<T extends WalletNotification>(type: T["notification_type"], listener: (notification: T["notification"]) => any): Subscription;
+    /** Get the wallet support info */
+    getSupport(): Promise<WalletSupport | null>;
+    /** Check if the wallet supports a method */
+    supportsMethod(method: WalletMethod): Promise<boolean>;
+    /** Check if the wallet supports notifications */
+    supportsNotifications(): Promise<boolean>;
+    /** Check if the wallet supports a notification type */
+    supportsNotificationType(type: NotificationType): Promise<boolean>;
+    /** Pay a lightning invoice */
+    payInvoice(invoice: string, amount?: number): Promise<PayInvoiceResult>;
+    /** Pay multiple lightning invoices */
+    payMultipleInvoices(invoices: Array<{
+        id?: string;
+        invoice: string;
+        amount?: number;
+    }>): Promise<PayInvoiceResult[]>;
+    /** Send a keysend payment */
+    payKeysend(pubkey: string, amount: number, preimage?: string, tlv_records?: Array<{
+        type: number;
+        value: string;
+    }>): Promise<PayKeysendResult>;
+    /** Send multiple keysend payments */
+    payMultipleKeysend(keysends: Array<{
+        id?: string;
+        pubkey: string;
+        amount: number;
+        preimage?: string;
+        tlv_records?: Array<{
+            type: number;
+            value: string;
+        }>;
+    }>): Promise<PayKeysendResult[]>;
+    /** Create a new invoice */
+    makeInvoice(amount: number, options?: Omit<MakeInvoiceParams, "amount">): Promise<MakeInvoiceResult>;
+    /** Look up an invoice by payment hash or invoice string */
+    lookupInvoice(payment_hash?: string, invoice?: string): Promise<LookupInvoiceResult>;
+    /** List transactions */
+    listTransactions(params?: {
+        from?: number;
+        until?: number;
+        limit?: number;
+        offset?: number;
+        unpaid?: boolean;
+        type?: "incoming" | "outgoing";
+    }): Promise<ListTransactionsResult>;
+    /** Get wallet balance */
+    getBalance(): Promise<GetBalanceResult>;
+    /** Get wallet info */
+    getInfo(): Promise<GetInfoResult>;
+    /** Serialize the WalletConnect instance */
+    toJSON(): SerializedWalletConnect;
+    /** Create a new WalletConnect instance from a serialized object */
+    static fromJSON(json: SerializedWalletConnect, options?: WalletConnectOptions): WalletConnect;
+    /** Create a new WalletConnect instance from a connection string */
+    static fromConnectionString(connectionString: string, options?: WalletConnectOptions): WalletConnect;
+}

package/dist/wallet-connect.js

@@ -0,0 +1,271 @@
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { simpleTimeout } from "applesauce-core";
+import { create } from "applesauce-factory";
+import { finalizeEvent, getPublicKey, nip04, nip44, verifyEvent } from "nostr-tools";
+import { defer, filter, firstValueFrom, from, ignoreElements, lastValueFrom, map, merge, mergeMap, ReplaySubject, share, switchMap, timer, toArray, } from "rxjs";
+import { WalletRequestBlueprint } from "./blueprints/index.js";
+import { createWalletError } from "./helpers/error.js";
+import { getPreferredEncryption, getWalletNotification, getWalletRequestEncryption, getWalletResponse, getWalletResponseRequestId, getWalletSupport, isWalletNotificationLocked, isWalletResponseLocked, parseWalletConnectURI, supportsMethod, supportsNotifications, supportsNotificationType, unlockWalletNotification, unlockWalletResponse, WALLET_INFO_KIND, WALLET_LEGACY_NOTIFICATION_KIND, WALLET_NOTIFICATION_KIND, WALLET_RESPONSE_KIND, } from "./helpers/index.js";
+export class WalletConnect {
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    static subscriptionMethod = undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    static publishMethod = undefined;
+    /** A method that is called when an event needs to be published */
+    publishMethod;
+    /** The active nostr subscription method */
+    subscriptionMethod;
+    /** The local client signer */
+    secret;
+    signer;
+    /** The relays to use for the connection */
+    relays;
+    /** The wallet service public key */
+    service;
+    /** Default timeout for requests */
+    defaultTimeout;
+    /** Observable for wallet info updates */
+    support$;
+    /** The preferred encryption method for the wallet */
+    encryption$;
+    /** Shared observable for all wallet response events and notifications */
+    events$;
+    /** Shared observable for all wallet notifications */
+    notifications$;
+    constructor(secret, service, relays, options = {}) {
+        this.service = service;
+        this.secret = secret;
+        this.relays = relays;
+        this.defaultTimeout = options.timeout || 30000; // 30 second default timeout
+        // Create a signer for the factory
+        this.signer = {
+            getPublicKey: async () => getPublicKey(this.secret),
+            signEvent: async (draft) => finalizeEvent(draft, this.secret),
+            nip04: {
+                encrypt: async (pubkey, plaintext) => nip04.encrypt(this.secret, pubkey, plaintext),
+                decrypt: async (pubkey, ciphertext) => nip04.decrypt(this.secret, pubkey, ciphertext),
+            },
+            nip44: {
+                encrypt: async (pubkey, plaintext) => nip44.encrypt(plaintext, nip44.getConversationKey(this.secret, pubkey)),
+                decrypt: async (pubkey, ciphertext) => nip44.decrypt(ciphertext, nip44.getConversationKey(this.secret, pubkey)),
+            },
+        };
+        const subscriptionMethod = options.subscriptionMethod || WalletConnect.subscriptionMethod;
+        if (!subscriptionMethod)
+            throw new Error("Missing subscriptionMethod, either pass a method or set WalletConnect.subscriptionMethod");
+        const publishMethod = options.publishMethod || WalletConnect.publishMethod;
+        if (!publishMethod)
+            throw new Error("Missing publishMethod, either pass a method or set WalletConnect.publishMethod");
+        this.subscriptionMethod = subscriptionMethod;
+        this.publishMethod = publishMethod;
+        // Create shared response observable with ref counting and timer
+        this.events$ = defer(() => this.signer.getPublicKey()).pipe(switchMap((client) => this.subscriptionMethod(this.relays, [
+            // Subscribe to response events
+            {
+                kinds: [WALLET_RESPONSE_KIND, WALLET_NOTIFICATION_KIND, WALLET_LEGACY_NOTIFICATION_KIND],
+                "#p": [client],
+                authors: [this.service],
+            },
+            // Subscribe to wallet info events
+            { kinds: [WALLET_INFO_KIND], authors: [this.service] },
+        ])), 
+        // Ingore strings (support for applesauce-relay)
+        filter((event) => typeof event !== "string"), 
+        // Only include events from the wallet service
+        filter((event) => event.pubkey === this.service), 
+        // Only create a single subscription to the relays
+        share({
+            resetOnRefCountZero: () => timer(60000), // Keep subscription open for 1 minute after last unsubscribe
+        }));
+        this.support$ = this.events$.pipe(filter((event) => event.kind === WALLET_INFO_KIND), map((event) => getWalletSupport(event)), share({
+            connector: () => new ReplaySubject(1),
+            resetOnRefCountZero: () => timer(60000), // Keep info observable around for 1 minute after last unsubscribe
+        }));
+        this.encryption$ = this.support$.pipe(map((info) => (info ? getPreferredEncryption(info) : "nip04")));
+        this.notifications$ = this.events$.pipe(filter((event) => event.kind === WALLET_NOTIFICATION_KIND), mergeMap((event) => this.handleNotificationEvent(event)));
+    }
+    /** Process response events and return WalletResponse or throw error */
+    async handleResponseEvent(event, encryption) {
+        if (!verifyEvent(event))
+            throw new Error("Invalid response event signature");
+        const requestId = getWalletResponseRequestId(event);
+        if (!requestId)
+            throw new Error("Response missing request ID");
+        let response;
+        if (isWalletResponseLocked(event))
+            response = await unlockWalletResponse(event, this.signer, encryption);
+        else
+            response = getWalletResponse(event);
+        if (!response)
+            throw new Error("Failed to decrypt or parse response");
+        return response;
+    }
+    /** Handle notification events */
+    async handleNotificationEvent(event) {
+        if (!verifyEvent(event))
+            throw new Error("Invalid notification event signature");
+        let notification;
+        if (isWalletNotificationLocked(event))
+            notification = await unlockWalletNotification(event, this.signer);
+        else
+            notification = getWalletNotification(event);
+        if (!notification)
+            throw new Error("Failed to decrypt or parse notification");
+        return notification;
+    }
+    /** Core RPC method that makes a request and returns the response */
+    request(request, options = {}) {
+        // Create the request evnet
+        return defer(async () => {
+            // Get the preferred encryption method for the wallet
+            const encryption = await firstValueFrom(this.encryption$);
+            // Create the request event
+            const draft = await create({ signer: this.signer }, WalletRequestBlueprint, this.service, request, encryption);
+            // Sign the request event
+            return await this.signer.signEvent(draft);
+        }).pipe(
+        // Then switch to the request observable
+        switchMap((requestEvent) => {
+            const encryption = getWalletRequestEncryption(requestEvent) === "nip44_v2" ? "nip44" : "nip04";
+            // Create an observable that publishes the request event when subscribed to
+            const request$ = defer(() => from(this.publishMethod(this.relays, requestEvent))).pipe(ignoreElements());
+            // Create an observable that listens for response events
+            const responses$ = this.events$.pipe(filter((response) => response.kind === WALLET_RESPONSE_KIND && getWalletResponseRequestId(response) === requestEvent.id), mergeMap((response) => this.handleResponseEvent(response, encryption)), 
+            // Set timeout for response events
+            simpleTimeout(options.timeout || this.defaultTimeout));
+            return merge(request$, responses$);
+        }));
+    }
+    /**
+     * Listen for a type of notification
+     * @returns a method to unsubscribe the listener
+     */
+    notification(type, listener) {
+        return this.notifications$.subscribe((notification) => {
+            if (notification.notification_type === type)
+                listener(notification.notification);
+        });
+    }
+    // Convenience methods that return promises for easy API usage
+    /** Get the wallet support info */
+    getSupport() {
+        return firstValueFrom(this.support$);
+    }
+    /** Check if the wallet supports a method */
+    async supportsMethod(method) {
+        const support = await this.getSupport();
+        return support ? supportsMethod(support, method) : false;
+    }
+    /** Check if the wallet supports notifications */
+    async supportsNotifications() {
+        const support = await this.getSupport();
+        return support ? supportsNotifications(support) : false;
+    }
+    /** Check if the wallet supports a notification type */
+    async supportsNotificationType(type) {
+        const support = await this.getSupport();
+        return support ? supportsNotificationType(support, type) : false;
+    }
+    /** Pay a lightning invoice */
+    async payInvoice(invoice, amount) {
+        const response = await firstValueFrom(this.request({ method: "pay_invoice", params: { invoice, amount } }));
+        if (response.result_type !== "pay_invoice")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Pay multiple lightning invoices */
+    async payMultipleInvoices(invoices) {
+        return await lastValueFrom(this.request({ method: "multi_pay_invoice", params: { invoices } })
+            .pipe(map((response) => {
+            if (response.result_type !== "multi_pay_invoice")
+                throw new Error(`Unexpected response type: ${response.result_type}`);
+            if (response.error)
+                throw createWalletError(response.error.type, response.error.message);
+            return response.result;
+        }))
+            .pipe(toArray()));
+    }
+    /** Send a keysend payment */
+    async payKeysend(pubkey, amount, preimage, tlv_records) {
+        const response = await firstValueFrom(this.request({ method: "pay_keysend", params: { pubkey, amount, preimage, tlv_records } }));
+        if (response.result_type !== "pay_keysend")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Send multiple keysend payments */
+    async payMultipleKeysend(keysends) {
+        return lastValueFrom(this.request({ method: "multi_pay_keysend", params: { keysends } }).pipe(map((response) => {
+            if (response.result_type !== "multi_pay_keysend")
+                throw new Error(`Unexpected response type: ${response.result_type}`);
+            if (response.error)
+                throw createWalletError(response.error.type, response.error.message);
+            return response.result;
+        }), toArray()));
+    }
+    /** Create a new invoice */
+    async makeInvoice(amount, options) {
+        const response = await firstValueFrom(this.request({ method: "make_invoice", params: { amount, ...options } }));
+        if (response.result_type !== "make_invoice")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Look up an invoice by payment hash or invoice string */
+    async lookupInvoice(payment_hash, invoice) {
+        const response = await firstValueFrom(this.request({ method: "lookup_invoice", params: { payment_hash, invoice } }));
+        if (response.result_type !== "lookup_invoice")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** List transactions */
+    async listTransactions(params) {
+        const response = await firstValueFrom(this.request({ method: "list_transactions", params: params || {} }));
+        if (response.result_type !== "list_transactions")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Get wallet balance */
+    async getBalance() {
+        const response = await firstValueFrom(this.request({ method: "get_balance", params: {} }));
+        if (response.result_type !== "get_balance")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Get wallet info */
+    async getInfo() {
+        const response = await firstValueFrom(this.request({ method: "get_info", params: {} }));
+        if (response.result_type !== "get_info")
+            throw new Error(`Unexpected response type: ${response.result_type}`);
+        if (response.error)
+            throw createWalletError(response.error.type, response.error.message);
+        return response.result;
+    }
+    /** Serialize the WalletConnect instance */
+    toJSON() {
+        return {
+            secret: bytesToHex(this.secret),
+            service: this.service,
+            relays: this.relays,
+        };
+    }
+    /** Create a new WalletConnect instance from a serialized object */
+    static fromJSON(json, options) {
+        return new WalletConnect(hexToBytes(json.secret), json.service, json.relays, options);
+    }
+    /** Create a new WalletConnect instance from a connection string */
+    static fromConnectionString(connectionString, options) {
+        const { secret, service, relays } = parseWalletConnectURI(connectionString);
+        return new WalletConnect(hexToBytes(secret), service, relays, options);
+    }
+}

package/dist/wallet-service.d.ts

@@ -0,0 +1,111 @@
+import { EventSigner } from "applesauce-factory";
+import { NostrEvent } from "nostr-tools";
+import { Observable, Subscription } from "rxjs";
+import { WalletErrorCode } from "./helpers/error.js";
+import { NotificationType, WalletNotification } from "./helpers/notification.js";
+import { GetBalanceParams, GetInfoParams, ListTransactionsParams, LookupInvoiceParams, MakeInvoiceParams, MultiPayInvoiceParams, MultiPayKeysendParams, PayInvoiceParams, PayKeysendParams, WalletRequest } from "./helpers/request.js";
+import { GetBalanceResult, GetInfoResult, ListTransactionsResult, LookupInvoiceResult, MakeInvoiceResult, MultiPayInvoiceResult, MultiPayKeysendResult, PayInvoiceResult, PayKeysendResult, WalletResponse } from "./helpers/response.js";
+import { WalletSupport } from "./helpers/support.js";
+import { NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
+/** Handler function for pay_invoice method */
+export type PayInvoiceHandler = (params: PayInvoiceParams) => Promise<PayInvoiceResult>;
+/** Handler function for multi_pay_invoice method */
+export type MultiPayInvoiceHandler = (params: MultiPayInvoiceParams) => Promise<MultiPayInvoiceResult[]>;
+/** Handler function for pay_keysend method */
+export type PayKeysendHandler = (params: PayKeysendParams) => Promise<PayKeysendResult>;
+/** Handler function for multi_pay_keysend method */
+export type MultiPayKeysendHandler = (params: MultiPayKeysendParams) => Promise<MultiPayKeysendResult[]>;
+/** Handler function for make_invoice method */
+export type MakeInvoiceHandler = (params: MakeInvoiceParams) => Promise<MakeInvoiceResult>;
+/** Handler function for lookup_invoice method */
+export type LookupInvoiceHandler = (params: LookupInvoiceParams) => Promise<LookupInvoiceResult>;
+/** Handler function for list_transactions method */
+export type ListTransactionsHandler = (params: ListTransactionsParams) => Promise<ListTransactionsResult>;
+/** Handler function for get_balance method */
+export type GetBalanceHandler = (params: GetBalanceParams) => Promise<GetBalanceResult>;
+/** Handler function for get_info method */
+export type GetInfoHandler = (params: GetInfoParams) => Promise<GetInfoResult>;
+/** Map of method handlers for the wallet service */
+export interface WalletServiceHandlers {
+    pay_invoice?: PayInvoiceHandler;
+    multi_pay_invoice?: MultiPayInvoiceHandler;
+    pay_keysend?: PayKeysendHandler;
+    multi_pay_keysend?: MultiPayKeysendHandler;
+    make_invoice?: MakeInvoiceHandler;
+    lookup_invoice?: LookupInvoiceHandler;
+    list_transactions?: ListTransactionsHandler;
+    get_balance?: GetBalanceHandler;
+    get_info?: GetInfoHandler;
+}
+/** Options for creating a WalletService */
+export interface WalletServiceOptions {
+    /** The relays to use for the service */
+    relays: string[];
+    /** The signer to use for creating and unlocking events */
+    signer: EventSigner;
+    /** The client's secret key */
+    secret?: Uint8Array;
+    /** Map of method handlers */
+    handlers: WalletServiceHandlers;
+    /** An array of notifications this wallet supports */
+    notifications?: NotificationType[];
+    /** An optional method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** An optional method for publishing events */
+    publishMethod?: NostrPublishMethod;
+}
+/** NIP-47 Wallet Service implementation */
+export declare class WalletService {
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    static subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    static publishMethod: NostrPublishMethod | undefined;
+    /** A method for subscribing to relays */
+    protected readonly subscriptionMethod: NostrSubscriptionMethod;
+    /** A method for publishing events */
+    protected readonly publishMethod: NostrPublishMethod;
+    protected log: import("debug").Debugger;
+    /** The relays to use for the service */
+    readonly relays: string[];
+    /** The signer used for creating and unlocking events */
+    protected readonly signer: EventSigner;
+    /** Map of method handlers */
+    protected readonly handlers: WalletServiceHandlers;
+    /** Wallet support information */
+    protected readonly support: WalletSupport;
+    /** The service's public key */
+    pubkey: string | null;
+    /** The client's secret key */
+    protected secret: Uint8Array;
+    /** Shared observable for all wallet request events */
+    protected events$: Observable<NostrEvent> | null;
+    /** Subscription to the events observable */
+    protected subscription: Subscription | null;
+    /** Whether the service is currently running */
+    running: boolean;
+    /** Get the clients public key */
+    get client(): string;
+    constructor(options: WalletServiceOptions);
+    /** Start the wallet service */
+    start(): Promise<void>;
+    /** Stop the wallet service */
+    stop(): void;
+    /** Check if the service is running */
+    isRunning(): boolean;
+    /** Get the connection string for the service */
+    getConnectionString(): string;
+    /** Send a notification to the client */
+    notify<T extends WalletNotification>(type: T["notification_type"], notification: T["notification"], legacy?: boolean): Promise<void>;
+    /** Publish the wallet support event */
+    protected publishSupportEvent(): Promise<void>;
+    /** Handle a wallet request event */
+    protected handleRequestEvent(requestEvent: NostrEvent): Promise<void>;
+    /** Process a decrypted wallet request */
+    protected processRequest(requestEvent: NostrEvent, request: WalletRequest): Promise<void>;
+    /** Send a success response */
+    protected sendSuccessResponse<T extends WalletResponse>(requestEvent: NostrEvent, method: T["result_type"], result: T["result"]): Promise<void>;
+    /** Send an error response */
+    protected sendErrorResponse(requestEvent: NostrEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
+    /** Send a response event */
+    protected sendResponse(requestEvent: NostrEvent, response: WalletResponse): Promise<void>;
+}