applesauce-wallet-connect 3.1.0 → 4.1.0

package/dist/wallet-connect.js

@@ -2,10 +2,10 @@ 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 { BehaviorSubject, defer, filter, firstValueFrom, from, fromEvent, identity, ignoreElements, lastValueFrom, map, merge, mergeMap, repeat, ReplaySubject, retry, share, switchMap, takeUntil, tap, timer, toArray, } from "rxjs";
+import { BehaviorSubject, combineLatest, defer, filter, firstValueFrom, from, fromEvent, identity, ignoreElements, lastValueFrom, map, merge, mergeMap, of, repeat, ReplaySubject, retry, share, switchMap, take, takeUntil, tap, timer, toArray, } from "rxjs";
 import { WalletRequestBlueprint } from "./blueprints/index.js";
 import { createWalletError } from "./helpers/error.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";
+import { createWalletAuthURI, getPreferredEncryption, getWalletRequestEncryption, getWalletResponseRequestId, getWalletSupport, isValidWalletNotification, isValidWalletResponse, parseWalletConnectURI, supportsMethod, supportsNotifications, supportsNotificationType, unlockWalletNotification, unlockWalletResponse, WALLET_INFO_KIND, WALLET_LEGACY_NOTIFICATION_KIND, WALLET_NOTIFICATION_KIND, WALLET_RESPONSE_KIND, } from "./helpers/index.js";
 import { getConnectionMethods, } from "./interop.js";
 export class WalletConnect {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
@@ -22,7 +22,12 @@ export class WalletConnect {
     secret;
     signer;
     /** The relays to use for the connection */
-    relays;
+    relays$ = new BehaviorSubject([]);
+    get relays() {
+        return this.relays$.value;
+    }
+    /** Whether to accept the relay hint from the wallet service */
+    acceptRelayHint;
     /** The wallet service public key ( unset if waiting for service ) */
     service$ = new BehaviorSubject(undefined);
     get service() {
@@ -42,7 +47,8 @@ export class WalletConnect {
     waitForService$;
     constructor(options) {
         this.secret = options.secret;
-        this.relays = options.relays;
+        this.relays$.next(options.relays);
+        this.acceptRelayHint = options.acceptRelayHint ?? true;
         this.service$.next(options.service);
         this.defaultTimeout = options.timeout || 30000; // 30 second default timeout
         // Create a signer for the factory
@@ -64,18 +70,18 @@ export class WalletConnect {
         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) => {
+        this.events$ = combineLatest([this.service$, this.relays$]).pipe(switchMap(([service, relays]) => {
             const client = getPublicKey(this.secret);
             // If the service is not known yet, subscribe to a wallet info event tagging the client
             if (!service)
-                return from(this.subscriptionMethod(this.relays, [{ kinds: [WALLET_INFO_KIND], "#p": [client] }])).pipe(
+                return from(this.subscriptionMethod(relays, [{ kinds: [WALLET_INFO_KIND], "#p": [client] }])).pipe(
                 // Keep the connection open indefinitely
                 repeat(), 
                 // Retry on connection failure
                 retry(), 
                 // Ignore strings (support for applesauce-relay)
                 filter((event) => typeof event !== "string"));
-            return from(this.subscriptionMethod(this.relays, [
+            return from(this.subscriptionMethod(relays, [
                 // Subscribe to response events
                 {
                     kinds: [WALLET_RESPONSE_KIND, WALLET_NOTIFICATION_KIND, WALLET_LEGACY_NOTIFICATION_KIND],
@@ -103,19 +109,30 @@ export class WalletConnect {
             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)));
-        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), 
+        this.notifications$ = this.events$.pipe(filter((event) => isValidWalletNotification(event)), mergeMap((event) => this.handleNotificationEvent(event)));
+        this.waitForService$ = defer(() => 
+        // If service is already set, return it
+        this.service$.value
+            ? of(this.service$.value)
+            : // Otherwise listen for new wallet info events
+                this.events$.pipe(
+                // Only listen for wallet info events
+                filter((event) => event.kind === WALLET_INFO_KIND), 
+                // 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);
+                    // Switch to the relay from the service if its set
+                    if (this.acceptRelayHint) {
+                        const relay = event.tags.find((t) => t[0] === "p" && t[2])?.[2];
+                        if (relay)
+                            this.relays$.next([relay]);
+                    }
+                }), 
+                // Get the service pubkey from the event
+                map((event) => event.pubkey), 
+                // Complete after the first value
+                take(1))).pipe(
         // Only create a single subscription to avoid multiple side effects
         share());
     }
@@ -126,11 +143,7 @@ export class WalletConnect {
         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);
+        const response = await unlockWalletResponse(event, this.signer, encryption);
         if (!response)
             throw new Error("Failed to decrypt or parse response");
         return response;
@@ -139,25 +152,21 @@ export class WalletConnect {
     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);
+        const notification = await unlockWalletNotification(event, this.signer);
         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 = {}) {
+    /** Generic call method with generic type */
+    genericCall(method, params, options = {}) {
         if (!this.service)
             throw new Error("WalletConnect is not connected to a service");
-        // Create the request evnet
+        // Create the request event
         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);
+            const draft = await create({ signer: this.signer }, WalletRequestBlueprint, this.service, { method, params }, encryption);
             // Sign the request event
             return await this.signer.signEvent(draft);
         }).pipe(
@@ -167,12 +176,29 @@ export class WalletConnect {
             // 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)), 
+            const responses$ = this.events$.pipe(filter(isValidWalletResponse), filter((response) => getWalletResponseRequestId(response) === requestEvent.id), mergeMap((response) => this.handleResponseEvent(response, encryption)), 
             // Set timeout for response events
             simpleTimeout(options.timeout || this.defaultTimeout));
             return merge(request$, responses$);
         }));
     }
+    /** Request method with generic type */
+    async genericRequest(method, params, options = {}) {
+        const result = await firstValueFrom(this.genericCall(method, params, options));
+        if (result.result_type !== method)
+            throw new Error(`Unexpected response type: ${result.result_type}`);
+        if (result.error)
+            throw createWalletError(result.error.type, result.error.message);
+        return result.result;
+    }
+    /** Call a method and return an observable of results */
+    call(method, params, options = {}) {
+        return this.genericCall(method, params, options);
+    }
+    /** Typed request method, returns the result or throws and error */
+    async request(method, params, options = {}) {
+        return this.genericRequest(method, params, options);
+    }
     /**
      * Listen for a type of notification
      * @returns a method to unsubscribe the listener
@@ -215,18 +241,14 @@ export class WalletConnect {
         const support = await this.getSupport();
         return support ? supportsNotificationType(support, type) : false;
     }
+    // Methods for common types
     /** 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;
+        return await this.genericRequest("pay_invoice", { invoice, amount });
     }
     /** Pay multiple lightning invoices */
     async payMultipleInvoices(invoices) {
-        return await lastValueFrom(this.request({ method: "multi_pay_invoice", params: { invoices } })
+        return await lastValueFrom(this.genericCall("multi_pay_invoice", { invoices })
             .pipe(map((response) => {
             if (response.result_type !== "multi_pay_invoice")
                 throw new Error(`Unexpected response type: ${response.result_type}`);
@@ -238,16 +260,11 @@ export class WalletConnect {
     }
     /** 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;
+        return await this.genericRequest("pay_keysend", { pubkey, amount, preimage, tlv_records });
     }
     /** Send multiple keysend payments */
     async payMultipleKeysend(keysends) {
-        return lastValueFrom(this.request({ method: "multi_pay_keysend", params: { keysends } }).pipe(map((response) => {
+        return lastValueFrom(this.genericCall("multi_pay_keysend", { keysends }).pipe(map((response) => {
             if (response.result_type !== "multi_pay_keysend")
                 throw new Error(`Unexpected response type: ${response.result_type}`);
             if (response.error)
@@ -257,48 +274,23 @@ export class WalletConnect {
     }
     /** 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;
+        return await this.genericRequest("make_invoice", { amount, ...options });
     }
     /** 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;
+        return await this.genericRequest("lookup_invoice", { payment_hash, invoice });
     }
     /** 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;
+        return await this.genericRequest("list_transactions", params || {});
     }
     /** 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;
+        return await this.genericRequest("get_balance", {});
     }
     /** 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;
+        return await this.genericRequest("get_info", {});
     }
     /** Serialize the WalletConnect instance */
     toJSON() {

package/dist/wallet-service.d.ts

@@ -1,51 +1,31 @@
 import { EventSigner } from "applesauce-factory";
-import { NostrEvent } from "nostr-tools";
 import { Observable, Subscription } from "rxjs";
 import { WalletAuthURI } from "./helpers/auth-uri.js";
 import { WalletErrorCode } from "./helpers/error.js";
+import { CommonWalletMethods, TWalletMethod, WalletInfo } from "./helpers/methods.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 { WalletRequestEvent } from "./helpers/request.js";
 import { WalletSupport } from "./helpers/support.js";
 import { NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./interop.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;
-}
+/** Generic type for wallet method handlers */
+export type WalletMethodHandler<Method extends TWalletMethod> = (params: Method["request"]["params"]) => Promise<Method["response"]["result"]>;
+/** Map of method handlers for the wallet service for a specific set of methods */
+export type WalletServiceHandlers<Methods extends TWalletMethod = TWalletMethod> = {
+    [K in Methods["method"]]?: WalletMethodHandler<Extract<Methods, {
+        method: K;
+    }>>;
+};
+/** Serialized wallet service */
 export type SerializedWalletService = {
     /** The client's public key */
     client: string;
     /** The relays to use for the service */
     relays: string[];
 };
+/** Only the necessary info for the getInfo method on wallet service */
+export type WalletServiceInfo = Partial<Omit<WalletInfo, "methods" | "notifications">>;
 /** Options for creating a WalletService */
-export interface WalletServiceOptions extends NostrConnectionMethodsOptions {
+export interface WalletServiceOptions<Methods extends TWalletMethod = CommonWalletMethods> extends NostrConnectionMethodsOptions {
     /** The relays to use for the service */
     relays: string[];
     /** The signer to use for creating and unlocking events */
@@ -54,13 +34,15 @@ export interface WalletServiceOptions extends NostrConnectionMethodsOptions {
     secret?: Uint8Array;
     /** The client's public key (used for restoring the service) */
     client?: string;
+    /** A method for getting the general wallet information (Can be overwritten if get_info is set in handlers) */
+    getInfo?: () => Promise<WalletServiceInfo>;
     /** Map of method handlers */
-    handlers: WalletServiceHandlers;
+    handlers: WalletServiceHandlers<Methods>;
     /** An array of notifications this wallet supports */
     notifications?: NotificationType[];
 }
 /** NIP-47 Wallet Service implementation */
-export declare class WalletService {
+export declare class WalletService<Methods extends TWalletMethod = CommonWalletMethods> {
     /** 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 */
@@ -72,27 +54,29 @@ export declare class WalletService {
     /** A method for publishing events */
     protected readonly publishMethod: NostrPublishMethod;
     protected log: import("debug").Debugger;
+    /** A special method for getting the generic wallet information */
+    getInfo?: () => Promise<WalletServiceInfo>;
     /** 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;
+    protected readonly handlers: WalletServiceHandlers<Methods>;
     /** Wallet support information */
-    protected readonly support: WalletSupport;
+    protected readonly support: WalletSupport<Methods>;
     /** The service's public key */
     pubkey: string | null;
     /** The client's secret key */
-    protected secret: Uint8Array;
+    protected secret?: Uint8Array;
     /** The client's public key */
     client: string;
     /** Shared observable for all wallet request events */
-    protected events$: Observable<NostrEvent> | null;
+    protected events$: Observable<WalletRequestEvent> | null;
     /** Subscription to the events observable */
     protected subscription: Subscription | null;
     /** Whether the service is currently running */
     running: boolean;
-    constructor(options: WalletServiceOptions);
+    constructor(options: WalletServiceOptions<Methods>);
     /** Start the wallet service */
     start(): Promise<void>;
     /** Stop the wallet service */
@@ -106,15 +90,18 @@ export declare class WalletService {
     /** Publish the wallet support event */
     protected publishSupportEvent(): Promise<void>;
     /** Handle a wallet request event */
-    protected handleRequestEvent(requestEvent: NostrEvent): Promise<void>;
+    protected handleRequestEvent(requestEvent: WalletRequestEvent): Promise<void>;
     /** Process a decrypted wallet request */
-    protected processRequest(requestEvent: NostrEvent, request: WalletRequest): Promise<void>;
+    protected processRequest<Method extends Methods>(requestEvent: WalletRequestEvent, request: Method["request"]): Promise<void>;
     /** Send a success response */
-    protected sendSuccessResponse<T extends WalletResponse>(requestEvent: NostrEvent, method: T["result_type"], result: T["result"]): Promise<void>;
+    protected sendSuccessResponse<Method extends Methods>(requestEvent: WalletRequestEvent, method: Method["response"]["result_type"], result: Method["response"]["result"]): Promise<void>;
     /** Send an error response */
-    protected sendErrorResponse(requestEvent: NostrEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
+    protected sendErrorResponse<Method extends Methods>(requestEvent: WalletRequestEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
     /** Send a response event */
-    protected sendResponse(requestEvent: NostrEvent, response: WalletResponse): Promise<void>;
+    protected sendResponse<Method extends Methods>(requestEvent: WalletRequestEvent, response: Method["response"] | Method["error"]): Promise<void>;
     /** Creates a service for a nostr+walletauth URI */
-    static fromAuthURI(uri: string | WalletAuthURI, options: Omit<WalletServiceOptions, "relays">): WalletService;
+    static fromAuthURI<Methods extends TWalletMethod = CommonWalletMethods>(uri: string | WalletAuthURI, options: Omit<WalletServiceOptions<Methods>, "relays"> & {
+        /** A relay or method to select a single relay for the client and service to communicate over */
+        overrideRelay?: string | ((relays: string[]) => string);
+    }): WalletService<Methods>;
 }

package/dist/wallet-service.js

@@ -7,8 +7,8 @@ import { WalletLegacyNotificationBlueprint, WalletNotificationBlueprint } from "
 import { WalletResponseBlueprint } from "./blueprints/response.js";
 import { WalletSupportBlueprint } from "./blueprints/support.js";
 import { parseWalletAuthURI } from "./helpers/auth-uri.js";
-import { WalletBaseError } from "./helpers/error.js";
-import { getWalletRequest, isWalletRequestExpired, isWalletRequestLocked, unlockWalletRequest, WALLET_REQUEST_KIND, } from "./helpers/request.js";
+import { NotImplementedError, WalletBaseError } from "./helpers/error.js";
+import { getWalletRequest, isValidWalletRequest, isWalletRequestExpired, unlockWalletRequest, WALLET_REQUEST_KIND, } from "./helpers/request.js";
 import { getConnectionMethods, } from "./interop.js";
 /** NIP-47 Wallet Service implementation */
 export class WalletService {
@@ -23,6 +23,8 @@ export class WalletService {
     /** A method for publishing events */
     publishMethod;
     log = logger.extend("WalletService");
+    /** A special method for getting the generic wallet information */
+    getInfo;
     /** The relays to use for the service */
     relays;
     /** The signer used for creating and unlocking events */
@@ -49,10 +51,16 @@ export class WalletService {
         this.handlers = options.handlers;
         // Set the client's secret and public key
         if (options.secret) {
+            // Service was created with a custom secret
             this.secret = options.secret;
             this.client = getPublicKey(this.secret);
         }
+        else if (options.client) {
+            // Service was restored with only the clients pubkey
+            this.client = options.client;
+        }
         else {
+            // Generate secret and client pubkey
             this.secret = generateSecretKey();
             this.client = getPublicKey(this.secret);
         }
@@ -98,7 +106,9 @@ export class WalletService {
         // Ignore strings (support for applesauce-relay)
         filter((event) => typeof event !== "string"), 
         // Only include valid wallet request events
-        filter((event) => event.kind === WALLET_REQUEST_KIND && event.pubkey === this.client), 
+        filter(isValidWalletRequest), 
+        // Ensure they are to our pubkey
+        filter((event) => event.pubkey === this.client), 
         // Verify event signature
         filter((event) => verifyEvent(event)), 
         // Only create a single subscription to the relays
@@ -129,6 +139,8 @@ export class WalletService {
     }
     /** Get the connection URI for the service */
     getConnectURI() {
+        if (!this.secret)
+            throw new Error("Service was not created with a secret");
         if (!this.pubkey)
             throw new Error("Service is not running");
         if (!this.relays.length)
@@ -152,7 +164,9 @@ export class WalletService {
     /** Publish the wallet support event */
     async publishSupportEvent() {
         try {
-            const draft = await create({ signer: this.signer }, WalletSupportBlueprint, this.support, this.client);
+            // Tell the client which relay to use if there is only one (for nostr+walletauth URI connections)
+            const overrideRelay = this.relays.length === 1 ? this.relays[0] : undefined;
+            const draft = await create({ signer: this.signer }, (WalletSupportBlueprint), this.support, this.client, overrideRelay);
             const event = await this.signer.signEvent(draft);
             await this.publishMethod(this.relays, event);
         }
@@ -168,13 +182,7 @@ export class WalletService {
             if (isWalletRequestExpired(requestEvent))
                 return await this.sendErrorResponse(requestEvent, "OTHER", "Request has expired");
             // Unlock the request if needed
-            let request;
-            if (isWalletRequestLocked(requestEvent)) {
-                request = await unlockWalletRequest(requestEvent, this.signer);
-            }
-            else {
-                request = getWalletRequest(requestEvent);
-            }
+            const request = await unlockWalletRequest(requestEvent, this.signer);
             if (!request)
                 return await this.sendErrorResponse(requestEvent, "OTHER", "Failed to decrypt or parse request");
             // Handle the request based on its method
@@ -188,44 +196,27 @@ export class WalletService {
     /** Process a decrypted wallet request */
     async processRequest(requestEvent, request) {
         const handler = this.handlers[request.method];
-        if (!handler) {
-            await this.sendErrorResponse(requestEvent, "NOT_IMPLEMENTED", `Method ${request.method} not supported`);
-            return;
-        }
         try {
-            let result;
-            const method = request.method; // Store method for use in catch block
-            switch (method) {
-                case "pay_invoice":
-                    result = await handler(request.params);
-                    break;
-                case "multi_pay_invoice":
-                    result = await handler(request.params);
-                    break;
-                case "pay_keysend":
-                    result = await handler(request.params);
-                    break;
-                case "multi_pay_keysend":
-                    result = await handler(request.params);
-                    break;
-                case "make_invoice":
-                    result = await handler(request.params);
-                    break;
-                case "lookup_invoice":
-                    result = await handler(request.params);
-                    break;
-                case "list_transactions":
-                    result = await handler(request.params);
-                    break;
-                case "get_balance":
-                    result = await handler(request.params);
-                    break;
-                case "get_info":
-                    result = await handler(request.params);
-                    break;
+            let result = undefined;
+            // If the user has not implemented the method
+            if (!handler) {
+                // If its the get_info try to use the builtin getInfo method
+                if (request.method === "get_info") {
+                    result = { ...(this.getInfo?.() ?? {}), ...this.support };
+                }
+                else {
+                    // Else throw not supported error
+                    throw new NotImplementedError(`Method ${request.method} not supported`);
+                }
             }
+            // Otherwise use the user provided handler
+            if (!result && handler)
+                result = await handler(request.params);
+            // Throw if failed to get result
+            if (!result)
+                throw new NotImplementedError(`Method ${request.method} not supported`);
             // Send success response
-            await this.sendSuccessResponse(requestEvent, method, result);
+            await this.sendSuccessResponse(requestEvent, request.method, result);
         }
         catch (error) {
             this.log(`Error executing ${request.method}:`, error);
@@ -269,7 +260,7 @@ export class WalletService {
     /** Send a response event */
     async sendResponse(requestEvent, response) {
         try {
-            const draft = await create({ signer: this.signer }, WalletResponseBlueprint, requestEvent, response);
+            const draft = await create({ signer: this.signer }, WalletResponseBlueprint(requestEvent, response));
             const event = await this.signer.signEvent(draft);
             await this.publishMethod(this.relays, event);
         }
@@ -280,10 +271,13 @@ export class WalletService {
     }
     /** Creates a service for a nostr+walletauth URI */
     static fromAuthURI(uri, options) {
-        const { client, relays } = typeof uri === "string" ? parseWalletAuthURI(uri) : uri;
+        const authURI = typeof uri === "string" ? parseWalletAuthURI(uri) : uri;
+        const relays = options.overrideRelay
+            ? [typeof options.overrideRelay === "function" ? options.overrideRelay(authURI.relays) : options.overrideRelay]
+            : authURI.relays;
         return new WalletService({
             ...options,
-            client,
+            client: authURI.client,
             relays,
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet-connect",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -58,23 +58,25 @@
     }
   },
   "dependencies": {
-    "applesauce-core": "^3.1.0",
-    "applesauce-factory": "^3.1.0",
-    "nostr-tools": "~2.15",
     "@noble/hashes": "^1.7.1",
+    "applesauce-core": "^4.1.0",
+    "applesauce-factory": "^4.0.0",
+    "nostr-tools": "~2.17",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
     "@hirez_io/observer-spy": "^2.2.0",
     "@types/debug": "^4.1.12",
+    "rimraf": "^6.0.1",
     "typescript": "^5.8.3",
-    "vitest": "^3.2.3"
+    "vitest": "^3.2.4"
   },
   "funding": {
     "type": "lightning",
     "url": "lightning:nostrudel@geyser.fund"
   },
   "scripts": {
+    "prebuild": "rimraf dist",
     "build": "tsc",
     "watch:build": "tsc --watch > /dev/null",
     "test": "vitest run --passWithNoTests",