applesauce-wallet-connect 0.0.0-next-20250808173123 → 0.0.0-next-20250815164532

package/README.md

@@ -24,7 +24,7 @@ Connect to a wallet service using a connection string:
 ```typescript
 import { WalletConnect } from "applesauce-wallet-connect";
 
-const wallet = WalletConnect.fromConnectionString("nostr+walletconnect://relay.example.com?secret=...&pubkey=...");
+const wallet = WalletConnect.fromConnectURI("nostr+walletconnect://relay.example.com?secret=...&pubkey=...");
 
 // Pay an invoice
 const result = await wallet.payInvoice("lnbc1...");
@@ -87,10 +87,10 @@ await service.start();
 console.log("Wallet service started");
 
 // Get the connection string for the wallet service
-console.log(service.getConnectionString());
+console.log(service.getConnectURI());
 
 // Stop the service when done
-// service.stop();
+service.stop();
 ```
 
 ## Supported Methods

package/dist/blueprints/support.d.ts

@@ -1,4 +1,4 @@
 import { EventBlueprint } from "applesauce-factory";
 import { WalletSupport } from "../helpers/support.js";
 /** Creates a wallet info event */
-export declare function WalletSupportBlueprint(info: WalletSupport): EventBlueprint;
+export declare function WalletSupportBlueprint(info: WalletSupport, client?: string): EventBlueprint;

package/dist/blueprints/support.js

@@ -3,6 +3,8 @@ import { setContent } from "applesauce-factory/operations/content";
 import { includeSingletonTag } from "applesauce-factory/operations";
 import { WALLET_INFO_KIND } from "../helpers/support.js";
 /** Creates a wallet info event */
-export function WalletSupportBlueprint(info) {
-    return blueprint(WALLET_INFO_KIND, setContent(info.methods.join(" ")), info.encryption ? includeSingletonTag(["encryption", info.encryption.join(" ")]) : undefined, info.notifications ? includeSingletonTag(["notifications", info.notifications.join(" ")]) : undefined);
+export function WalletSupportBlueprint(info, client) {
+    return blueprint(WALLET_INFO_KIND, setContent(info.methods.join(" ")), info.encryption ? includeSingletonTag(["encryption", info.encryption.join(" ")]) : undefined, info.notifications ? includeSingletonTag(["notifications", info.notifications.join(" ")]) : undefined, 
+    // An optional client pubkey to notify the service is created (used for nostr+walletauth URI connections)
+    client ? includeSingletonTag(["p", client]) : undefined);
 }

package/dist/helpers/auth-uri.d.ts

@@ -0,0 +1,44 @@
+import { NotificationType } from "./notification.js";
+import { WalletMethod } from "./support.js";
+export interface WalletAuthURI {
+    /** The public key of the client requesting authorization */
+    client: string;
+    /** Required. URL of the relay where the client intends to communicate with the wallet service */
+    relays: string[];
+    /** The name of the client app (optional) */
+    name?: string;
+    /** The URL of an icon of the client app to display on the confirmation page (optional) */
+    icon?: string;
+    /** URI to open after the connection is created (optional) */
+    returnTo?: string;
+    /** The connection cannot be used after this date. Unix timestamp in seconds (optional) */
+    expiresAt?: number;
+    /** The maximum amount in millisats that can be sent per renewal period (optional) */
+    maxAmount?: number;
+    /** The reset the budget at the end of the given budget renewal. Can be never (default), daily, weekly, monthly, yearly (optional) */
+    budgetRenewal?: "never" | "daily" | "weekly" | "monthly" | "yearly";
+    /** List of request types that you need permission for (optional) */
+    methods?: WalletMethod[];
+    /** List of notification types that you need permission for (optional) */
+    notifications?: NotificationType[];
+    /** The makes an isolated app connection / sub-wallet with its own balance and only access to its own transaction list (optional) */
+    isolated?: boolean;
+    /** Url encoded, JSON-serialized metadata that describes the app connection (optional) */
+    metadata?: Record<string, any>;
+    /** The wallet name for nostr+walletauth+walletname scheme (optional) */
+    walletName?: string;
+}
+/**
+ * Parses a nostr+walletauth URI
+ * @throws {Error} if the authorization URI is invalid
+ */
+export declare function parseWalletAuthURI(authURI: string): WalletAuthURI;
+/**
+ * Creates a nostr+walletauth URI from a WalletAuthURI object
+ */
+export declare function createWalletAuthURI(parts: WalletAuthURI): string;
+/**
+ * Validates a WalletAuthURI object
+ * @returns true if valid, throws Error if invalid
+ */
+export declare function validateWalletAuthURI(parts: WalletAuthURI): boolean;

package/dist/helpers/auth-uri.js

@@ -0,0 +1,113 @@
+import { mergeRelaySets } from "applesauce-core/helpers";
+/**
+ * Parses a nostr+walletauth URI
+ * @throws {Error} if the authorization URI is invalid
+ */
+export function parseWalletAuthURI(authURI) {
+    const { host, pathname, searchParams, protocol } = new URL(authURI);
+    // Check if it's a valid wallet auth protocol
+    if (!protocol.startsWith("nostr+walletauth")) {
+        throw new Error("invalid wallet auth uri protocol");
+    }
+    // Extract wallet name if present (nostr+walletauth+walletname://)
+    const walletName = protocol.includes("+") && protocol.split("+").length > 2 ? protocol.split("+")[2]?.replace(/:$/, "") : undefined;
+    // The client pubkey is in the pathname or host
+    const client = pathname || host;
+    if (!client)
+        throw new Error("missing client public key in authorization URI");
+    // Relay is required
+    const relays = mergeRelaySets(searchParams.getAll("relay"));
+    if (relays.length === 0)
+        throw new Error("missing required relay parameter in authorization URI");
+    // Parse optional parameters
+    const name = searchParams.get("name") ?? undefined;
+    const icon = searchParams.get("icon") ?? undefined;
+    const returnTo = searchParams.get("return_to") ?? undefined;
+    const expiresAtParam = searchParams.get("expires_at");
+    const expiresAt = expiresAtParam ? parseInt(expiresAtParam, 10) : undefined;
+    const maxAmountParam = searchParams.get("max_amount");
+    const maxAmount = maxAmountParam ? parseInt(maxAmountParam, 10) : undefined;
+    const budgetRenewal = searchParams.get("budget_renewal");
+    const methodsParam = searchParams.get("request_methods");
+    const methods = methodsParam ? methodsParam.split(" ") : undefined;
+    const notificationsParam = searchParams.get("notification_types");
+    const notifications = notificationsParam ? notificationsParam.split(" ") : undefined;
+    const isolatedParam = searchParams.get("isolated");
+    const isolated = isolatedParam ? isolatedParam === "true" : undefined;
+    const metadataParam = searchParams.get("metadata");
+    let metadata;
+    if (metadataParam) {
+        try {
+            metadata = JSON.parse(decodeURIComponent(metadataParam));
+        }
+        catch (error) {
+            throw new Error("invalid metadata parameter in authorization URI");
+        }
+    }
+    return {
+        client,
+        relays,
+        name,
+        icon,
+        returnTo,
+        expiresAt,
+        maxAmount,
+        budgetRenewal: budgetRenewal || undefined,
+        methods,
+        notifications,
+        isolated,
+        metadata,
+        walletName,
+    };
+}
+/**
+ * Creates a nostr+walletauth URI from a WalletAuthURI object
+ */
+export function createWalletAuthURI(parts) {
+    validateWalletAuthURI(parts);
+    // Determine the protocol based on whether wallet name is specified
+    const protocol = parts.walletName ? `nostr+walletauth+${parts.walletName}` : "nostr+walletauth";
+    const url = new URL(`${protocol}://${parts.client}`);
+    // Add required relay parameter
+    for (const relay of parts.relays)
+        url.searchParams.append("relay", relay);
+    // Add optional parameters
+    if (parts.name)
+        url.searchParams.append("name", parts.name);
+    if (parts.icon)
+        url.searchParams.append("icon", parts.icon);
+    if (parts.returnTo)
+        url.searchParams.append("return_to", parts.returnTo);
+    if (parts.expiresAt)
+        url.searchParams.append("expires_at", parts.expiresAt.toString());
+    if (parts.maxAmount)
+        url.searchParams.append("max_amount", parts.maxAmount.toString());
+    if (parts.budgetRenewal && parts.budgetRenewal !== "never")
+        url.searchParams.append("budget_renewal", parts.budgetRenewal);
+    if (parts.methods && parts.methods.length > 0)
+        url.searchParams.append("request_methods", parts.methods.join(" "));
+    if (parts.notifications && parts.notifications.length > 0)
+        url.searchParams.append("notification_types", parts.notifications.join(" "));
+    if (parts.isolated !== undefined)
+        url.searchParams.append("isolated", parts.isolated.toString());
+    if (parts.metadata)
+        url.searchParams.append("metadata", encodeURIComponent(JSON.stringify(parts.metadata)));
+    return url.toString();
+}
+/**
+ * Validates a WalletAuthURI object
+ * @returns true if valid, throws Error if invalid
+ */
+export function validateWalletAuthURI(parts) {
+    if (!parts.client || parts.client.length === 0)
+        throw new Error("client public key is required");
+    if (!parts.relays || parts.relays.length === 0)
+        throw new Error("at least one relay is required");
+    if (parts.expiresAt && parts.expiresAt <= Math.floor(Date.now() / 1000))
+        throw new Error("expires_at must be in the future");
+    if (parts.maxAmount && parts.maxAmount <= 0)
+        throw new Error("max_amount must be positive");
+    if (parts.budgetRenewal && !["never", "daily", "weekly", "monthly", "yearly"].includes(parts.budgetRenewal))
+        throw new Error("invalid budget_renewal value");
+    return true;
+}

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

@@ -1,7 +1,12 @@
 export interface WalletConnectURI {
+    /** The pubkey of the wallet service */
     service: string;
+    /** The relays to use for the connection */
     relays: string[];
+    /** The secret key that the client will use to encrypt messages */
     secret: string;
+    /** An optional lub16 lightning address that is associated with the wallet */
+    lud16?: string;
 }
 /**
  * Parses a nostr+walletconnect URI

package/dist/helpers/connect-uri.js

@@ -1,3 +1,4 @@
+import { mergeRelaySets } from "applesauce-core/helpers";
 /**
  * Parses a nostr+walletconnect URI
  * @throws {Error} if the connection string is invalid
@@ -7,11 +8,12 @@ export function parseWalletConnectURI(connectionString) {
     if (protocol !== "nostr+walletconnect:")
         throw new Error("invalid wallet connect uri protocol");
     const service = pathname || host;
-    const relays = searchParams.getAll("relay");
+    const relays = mergeRelaySets(searchParams.getAll("relay"));
     const secret = searchParams.get("secret");
+    const lud16 = searchParams.get("lud16") ?? undefined;
     if (!service || relays.length === 0 || !secret)
         throw new Error("invalid connection string");
-    return { service, relays, secret };
+    return { service, relays, secret, lud16 };
 }
 /** Creates a nostr+walletconnect URI from a WalletConnectURI object */
 export function createWalletConnectURI(parts) {
@@ -19,5 +21,7 @@ export function createWalletConnectURI(parts) {
     for (const relay of parts.relays)
         url.searchParams.append("relay", relay);
     url.searchParams.append("secret", parts.secret);
+    if (parts.lud16)
+        url.searchParams.append("lud16", parts.lud16);
     return url.toString();
 }

package/dist/helpers/index.d.ts

@@ -5,3 +5,4 @@ export * from "./response.js";
 export * from "./support.js";
 export * from "./notification.js";
 export * from "./encryption.js";
+export * from "./auth-uri.js";

package/dist/helpers/index.js

@@ -5,3 +5,4 @@ export * from "./response.js";
 export * from "./support.js";
 export * from "./notification.js";
 export * from "./encryption.js";
+export * from "./auth-uri.js";

package/dist/types.d.ts

@@ -4,3 +4,8 @@ import { Observable } from "rxjs";
 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>;
+/** A simple pool type that combines the subscription and publish methods */
+export type NostrPool = {
+    subscription: NostrSubscriptionMethod;
+    publish: NostrPublishMethod;
+};

package/dist/wallet-connect.d.ts

@@ -1,23 +1,33 @@
+import { EncryptionMethod } from "applesauce-core/helpers";
 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";
+import { BehaviorSubject, Observable, Subscription } from "rxjs";
+import { GetBalanceResult, GetInfoResult, ListTransactionsResult, LookupInvoiceResult, MakeInvoiceParams, MakeInvoiceResult, NotificationType, PayInvoiceResult, PayKeysendResult, WalletAuthURI, WalletConnectEncryptionMethod, WalletConnectURI, WalletMethod, WalletNotification, WalletRequest, WalletResponse, WalletSupport } from "./helpers/index.js";
+import { NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
 export type SerializedWalletConnect = WalletConnectURI;
 export type WalletConnectOptions = {
+    /** The secret to use for the connection */
+    secret: Uint8Array;
+    /** The relays to use for the connection */
+    relays: string[];
+    /** The service pubkey to use for the connection (optional) */
+    service?: string;
+    /** Default timeout for RPC requests in milliseconds */
+    timeout?: number;
     /** A method for subscribing to relays */
     subscriptionMethod?: NostrSubscriptionMethod;
     /** A method for publishing events */
     publishMethod?: NostrPublishMethod;
-    /** Default timeout for RPC requests in milliseconds */
-    timeout?: number;
+    /** An optional pool for connection methods */
+    pool?: NostrPool;
 };
 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 fallback pool to use if none is pass in when creating the signer */
+    static pool: NostrPool | undefined;
     /** A method that is called when an event needs to be published */
     protected publishMethod: NostrPublishMethod;
     /** The active nostr subscription method */
@@ -27,8 +37,9 @@ export declare class WalletConnect {
     protected readonly signer: EventSigner;
     /** The relays to use for the connection */
     readonly relays: string[];
-    /** The wallet service public key */
-    readonly service: string;
+    /** The wallet service public key ( unset if waiting for service ) */
+    service$: BehaviorSubject<string | undefined>;
+    get service(): string | undefined;
     /** Default timeout for requests */
     defaultTimeout: number;
     /** Observable for wallet info updates */
@@ -39,7 +50,9 @@ export declare class WalletConnect {
     protected events$: Observable<NostrEvent>;
     /** Shared observable for all wallet notifications */
     notifications$: Observable<WalletNotification>;
-    constructor(secret: Uint8Array, service: string, relays: string[], options?: WalletConnectOptions);
+    /** An internal observable for listening for the wallet service to connect */
+    protected waitForService$: Observable<string>;
+    constructor(options: WalletConnectOptions);
     /** Process response events and return WalletResponse or throw error */
     protected handleResponseEvent(event: NostrEvent, encryption?: EncryptionMethod): Promise<WalletResponse>;
     /** Handle notification events */
@@ -53,6 +66,10 @@ export declare class WalletConnect {
      * @returns a method to unsubscribe the listener
      */
     notification<T extends WalletNotification>(type: T["notification_type"], listener: (notification: T["notification"]) => any): Subscription;
+    /** Gets the nostr+walletauth URI for the connection */
+    getAuthURI(parts?: Omit<WalletAuthURI, "client" | "relays">): string;
+    /** Wait for the wallet service to connect */
+    waitForService(abortSignal?: AbortSignal): Promise<string>;
     /** Get the wallet support info */
     getSupport(): Promise<WalletSupport | null>;
     /** Check if the wallet supports a method */
@@ -105,7 +122,7 @@ export declare class WalletConnect {
     /** Serialize the WalletConnect instance */
     toJSON(): SerializedWalletConnect;
     /** Create a new WalletConnect instance from a serialized object */
-    static fromJSON(json: SerializedWalletConnect, options?: WalletConnectOptions): WalletConnect;
+    static fromJSON(json: SerializedWalletConnect, options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">): WalletConnect;
     /** Create a new WalletConnect instance from a connection string */
-    static fromConnectionString(connectionString: string, options?: WalletConnectOptions): WalletConnect;
+    static fromConnectURI(connectionString: string, options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">): WalletConnect;
 }

package/dist/wallet-connect.js

@@ -2,15 +2,17 @@ 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 { BehaviorSubject, defer, filter, firstValueFrom, from, fromEvent, identity, ignoreElements, lastValueFrom, map, merge, mergeMap, ReplaySubject, share, switchMap, takeUntil, tap, 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";
+import { createWalletAuthURI, 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 fallback pool to use if none is pass in when creating the signer */
+    static pool = undefined;
     /** A method that is called when an event needs to be published */
     publishMethod;
     /** The active nostr subscription method */
@@ -20,8 +22,11 @@ export class WalletConnect {
     signer;
     /** The relays to use for the connection */
     relays;
-    /** The wallet service public key */
-    service;
+    /** The wallet service public key ( unset if waiting for service ) */
+    service$ = new BehaviorSubject(undefined);
+    get service() {
+        return this.service$.value;
+    }
     /** Default timeout for requests */
     defaultTimeout;
     /** Observable for wallet info updates */
@@ -32,10 +37,12 @@ export class WalletConnect {
     events$;
     /** Shared observable for all wallet notifications */
     notifications$;
-    constructor(secret, service, relays, options = {}) {
-        this.service = service;
-        this.secret = secret;
-        this.relays = relays;
+    /** An internal observable for listening for the wallet service to connect */
+    waitForService$;
+    constructor(options) {
+        this.secret = options.secret;
+        this.relays = options.relays;
+        this.service$.next(options.service);
         this.defaultTimeout = options.timeout || 30000; // 30 second default timeout
         // Create a signer for the factory
         this.signer = {
@@ -50,29 +57,42 @@ export class WalletConnect {
                 decrypt: async (pubkey, ciphertext) => nip44.decrypt(ciphertext, nip44.getConversationKey(this.secret, pubkey)),
             },
         };
-        const subscriptionMethod = options.subscriptionMethod || WalletConnect.subscriptionMethod;
+        // Get the subscription and publish methods
+        const subscriptionMethod = options.subscriptionMethod ||
+            options.pool?.subscription ||
+            WalletConnect.subscriptionMethod ||
+            WalletConnect.pool?.subscription;
         if (!subscriptionMethod)
             throw new Error("Missing subscriptionMethod, either pass a method or set WalletConnect.subscriptionMethod");
-        const publishMethod = options.publishMethod || WalletConnect.publishMethod;
+        const publishMethod = options.publishMethod || options.pool?.publish || WalletConnect.publishMethod || WalletConnect.pool?.publish;
         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), 
+        // Use arrow functions so "this" isn't bound to the signer
+        this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
+        this.publishMethod = (relays, event) => publishMethod(relays, event);
+        // Create shared observable for all wallet events
+        this.events$ = this.service$.pipe(switchMap((service) => {
+            const client = getPublicKey(this.secret);
+            // If the service is not known yet, subscribe to a wallet info event tagging the client
+            if (!service)
+                return this.subscriptionMethod(this.relays, [{ kinds: [WALLET_INFO_KIND], "#p": [client] }]).pipe(
+                // Ignore strings (support for applesauce-relay)
+                filter((event) => typeof event !== "string"));
+            return this.subscriptionMethod(this.relays, [
+                // Subscribe to response events
+                {
+                    kinds: [WALLET_RESPONSE_KIND, WALLET_NOTIFICATION_KIND, WALLET_LEGACY_NOTIFICATION_KIND],
+                    "#p": [client],
+                    authors: [service],
+                },
+                // Subscribe to wallet info events
+                { kinds: [WALLET_INFO_KIND], authors: [service] },
+            ]).pipe(
+            // Ignore strings (support for applesauce-relay)
+            filter((event) => typeof event !== "string"), 
+            // Only include events from the wallet service
+            filter((event) => event.pubkey === service));
+        }), 
         // Only create a single subscription to the relays
         share({
             resetOnRefCountZero: () => timer(60000), // Keep subscription open for 1 minute after last unsubscribe
@@ -83,6 +103,20 @@ export class WalletConnect {
         }));
         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)));
+        this.waitForService$ = this.events$.pipe(
+        // Complete when the service is set
+        takeUntil(this.service$), 
+        // Only listen for wallet info events
+        filter((event) => event.kind === WALLET_INFO_KIND && !this.service), 
+        // Set the service to the pubkey of the wallet info event
+        tap((event) => {
+            // Set the service to the pubkey of the wallet info event
+            this.service$.next(event.pubkey);
+        }), 
+        // Get the service pubkey from the event
+        map((event) => event.pubkey), 
+        // Only create a single subscription to avoid multiple side effects
+        share());
     }
     /** Process response events and return WalletResponse or throw error */
     async handleResponseEvent(event, encryption) {
@@ -115,6 +149,8 @@ export class WalletConnect {
     }
     /** Core RPC method that makes a request and returns the response */
     request(request, options = {}) {
+        if (!this.service)
+            throw new Error("WalletConnect is not connected to a service");
         // Create the request evnet
         return defer(async () => {
             // Get the preferred encryption method for the wallet
@@ -146,6 +182,18 @@ export class WalletConnect {
                 listener(notification.notification);
         });
     }
+    /** Gets the nostr+walletauth URI for the connection */
+    getAuthURI(parts) {
+        return createWalletAuthURI({ ...parts, client: getPublicKey(this.secret), relays: this.relays });
+    }
+    /** Wait for the wallet service to connect */
+    async waitForService(abortSignal) {
+        if (this.service)
+            return this.service;
+        return await firstValueFrom(this.waitForService$.pipe(
+        // Listen for abort signal
+        abortSignal ? takeUntil(fromEvent(abortSignal, "abort")) : identity));
+    }
     // Convenience methods that return promises for easy API usage
     /** Get the wallet support info */
     getSupport() {
@@ -253,6 +301,8 @@ export class WalletConnect {
     }
     /** Serialize the WalletConnect instance */
     toJSON() {
+        if (!this.service)
+            throw new Error("WalletConnect is not connected to a service");
         return {
             secret: bytesToHex(this.secret),
             service: this.service,
@@ -261,11 +311,21 @@ export class WalletConnect {
     }
     /** Create a new WalletConnect instance from a serialized object */
     static fromJSON(json, options) {
-        return new WalletConnect(hexToBytes(json.secret), json.service, json.relays, options);
+        return new WalletConnect({
+            ...options,
+            secret: hexToBytes(json.secret),
+            service: json.service,
+            relays: json.relays,
+        });
     }
     /** Create a new WalletConnect instance from a connection string */
-    static fromConnectionString(connectionString, options) {
+    static fromConnectURI(connectionString, options) {
         const { secret, service, relays } = parseWalletConnectURI(connectionString);
-        return new WalletConnect(hexToBytes(secret), service, relays, options);
+        return new WalletConnect({
+            ...options,
+            secret: hexToBytes(secret),
+            service,
+            relays,
+        });
     }
 }

package/dist/wallet-service.d.ts

@@ -6,7 +6,8 @@ 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";
+import { NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
+import { WalletAuthURI } from "./helpers/auth-uri.js";
 /** Handler function for pay_invoice method */
 export type PayInvoiceHandler = (params: PayInvoiceParams) => Promise<PayInvoiceResult>;
 /** Handler function for multi_pay_invoice method */
@@ -37,6 +38,12 @@ export interface WalletServiceHandlers {
     get_balance?: GetBalanceHandler;
     get_info?: GetInfoHandler;
 }
+export type SerializedWalletService = {
+    /** The client's public key */
+    client: string;
+    /** The relays to use for the service */
+    relays: string[];
+};
 /** Options for creating a WalletService */
 export interface WalletServiceOptions {
     /** The relays to use for the service */
@@ -45,6 +52,8 @@ export interface WalletServiceOptions {
     signer: EventSigner;
     /** The client's secret key */
     secret?: Uint8Array;
+    /** The client's public key (used for restoring the service) */
+    client?: string;
     /** Map of method handlers */
     handlers: WalletServiceHandlers;
     /** An array of notifications this wallet supports */
@@ -53,6 +62,8 @@ export interface WalletServiceOptions {
     subscriptionMethod?: NostrSubscriptionMethod;
     /** An optional method for publishing events */
     publishMethod?: NostrPublishMethod;
+    /** An optional pool for connection methods */
+    pool?: NostrPool;
 }
 /** NIP-47 Wallet Service implementation */
 export declare class WalletService {
@@ -60,6 +71,8 @@ export declare class WalletService {
     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 fallback pool to use if none is pass in when creating the signer */
+    static pool: NostrPool | undefined;
     /** A method for subscribing to relays */
     protected readonly subscriptionMethod: NostrSubscriptionMethod;
     /** A method for publishing events */
@@ -77,14 +90,14 @@ export declare class WalletService {
     pubkey: string | null;
     /** The client's secret key */
     protected secret: Uint8Array;
+    /** The client's public key */
+    client: string;
     /** 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>;
@@ -92,8 +105,8 @@ export declare class WalletService {
     stop(): void;
     /** Check if the service is running */
     isRunning(): boolean;
-    /** Get the connection string for the service */
-    getConnectionString(): string;
+    /** Get the connection URI for the service */
+    getConnectURI(): 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 */
@@ -108,4 +121,6 @@ export declare class WalletService {
     protected sendErrorResponse(requestEvent: NostrEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
     /** Send a response event */
     protected sendResponse(requestEvent: NostrEvent, response: WalletResponse): Promise<void>;
+    /** Creates a service for a nostr+walletauth URI */
+    static fromAuthURI(uri: string | WalletAuthURI, options: Omit<WalletServiceOptions, "relays">): WalletService;
 }