applesauce-wallet-connect 4.0.0 → 4.1.0

package/dist/helpers/support.d.ts

@@ -1,21 +1,21 @@
 import { NostrEvent } from "nostr-tools";
 import { WalletConnectEncryptionMethod } from "./encryption.js";
-import { NotificationType as NotificationType } from "./notification.js";
+import { TWalletMethod } from "./methods.js";
+import { NotificationType } from "./notification.js";
 export declare const WALLET_INFO_KIND = 13194;
 /** A symbol used to cache the wallet info on the event */
 export declare const WalletInfoSymbol: unique symbol;
-export type WalletMethod = "pay_invoice" | "multi_pay_invoice" | "pay_keysend" | "multi_pay_keysend" | "make_invoice" | "lookup_invoice" | "list_transactions" | "get_balance" | "get_info";
 /** Wallet service capabilities and information */
-export interface WalletSupport {
+export interface WalletSupport<Methods extends TWalletMethod = TWalletMethod> {
     /** List of supported methods for this wallet service */
-    methods: WalletMethod[];
+    methods: Array<Methods["method"]>;
     /** List of supported encryption methods */
     encryption: WalletConnectEncryptionMethod[];
     /** List of supported notifications, optional */
     notifications?: NotificationType[];
 }
 /** Gets the wallet info from a kind 13194 event */
-export declare function getWalletSupport(info: NostrEvent): WalletSupport | null;
+export declare function getWalletSupport<Methods extends TWalletMethod = TWalletMethod>(info: NostrEvent): WalletSupport<Methods> | null;
 /** Gets the encryption methods from a wallet info event */
 export declare function getEncryptionMethods(info: NostrEvent | WalletSupport): WalletConnectEncryptionMethod[];
 /** Checks if the wallet service supports a specific encryption method */
@@ -23,12 +23,12 @@ export declare function supportsEncryption(info: NostrEvent | WalletSupport, enc
 /** Gets the preferred encryption method (nip44_v2 preferred over nip04) */
 export declare function getPreferredEncryption(info: NostrEvent | WalletSupport): WalletConnectEncryptionMethod;
 /** Checks if the wallet service supports a specific method */
-export declare function supportsMethod(info: NostrEvent | WalletSupport, method: WalletMethod): boolean;
+export declare function supportsMethod(info: NostrEvent | WalletSupport, method: string): boolean;
 /** Checks if the wallet service supports notifications */
 export declare function supportsNotifications(info: NostrEvent | WalletSupport): boolean;
 /** Checks if the wallet service supports a specific notification type */
 export declare function supportsNotificationType(info: NostrEvent | WalletSupport, notificationType: NotificationType): boolean;
 /** Gets all supported methods from the wallet info */
-export declare function getSupportedMethods(info: NostrEvent | WalletSupport): WalletMethod[];
+export declare function getSupportedMethods(info: NostrEvent | WalletSupport): string[];
 /** Gets all supported notifications from the wallet info */
 export declare function getSupportedNotifications(info: NostrEvent | WalletSupport): NotificationType[];

package/dist/helpers/support.js

@@ -12,20 +12,7 @@ export function getWalletSupport(info) {
             return null;
         // Parse methods from content (space-separated)
         const contentParts = content.split(/\s+/);
-        const methods = contentParts
-            .filter((part) => [
-            "pay_invoice",
-            "multi_pay_invoice",
-            "pay_keysend",
-            "multi_pay_keysend",
-            "make_invoice",
-            "lookup_invoice",
-            "list_transactions",
-            "get_balance",
-            "get_info",
-            "notifications",
-        ].includes(part))
-            .filter((part) => part !== "notifications");
+        const methods = contentParts.filter((part) => part !== "notifications");
         // Parse encryption methods from encryption tag
         const encryptionTag = getTagValue(info, "encryption");
         const encryption = encryptionTag

package/dist/wallet-connect.d.ts

@@ -2,7 +2,8 @@ import { EncryptionMethod } from "applesauce-core/helpers";
 import { EventSigner } from "applesauce-factory";
 import { NostrEvent } from "nostr-tools";
 import { BehaviorSubject, Observable, Subscription } from "rxjs";
-import { GetBalanceResult, GetInfoResult, ListTransactionsResult, LookupInvoiceResult, MakeInvoiceParams, MakeInvoiceResult, NotificationType, PayInvoiceResult, PayKeysendResult, WalletAuthURI, WalletConnectEncryptionMethod, WalletConnectURI, WalletMethod, WalletNotification, WalletNotificationEvent, WalletRequest, WalletResponse, WalletResponseEvent, WalletSupport } from "./helpers/index.js";
+import { NotificationType, WalletAuthURI, WalletConnectEncryptionMethod, WalletConnectURI, WalletNotification, WalletNotificationEvent, WalletResponseEvent, WalletSupport } from "./helpers/index.js";
+import { CommonWalletMethods, GetBalanceMethod, GetInfoMethod, ListTransactionsMethod, LookupInvoiceMethod, MakeInvoiceMethod, MultiPayInvoiceMethod, MultiPayKeysendMethod, PayInvoiceMethod, PayKeysendMethod, TWalletMethod } from "./helpers/methods.js";
 import { NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./interop.js";
 export type SerializedWalletConnect = WalletConnectURI;
 export type WalletConnectOptions = NostrConnectionMethodsOptions & {
@@ -14,8 +15,10 @@ export type WalletConnectOptions = NostrConnectionMethodsOptions & {
     service?: string;
     /** Default timeout for RPC requests in milliseconds */
     timeout?: number;
+    /** Whether to accept the relay hint from the wallet service */
+    acceptRelayHint?: boolean;
 };
-export declare class WalletConnect {
+export declare class WalletConnect<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 */
@@ -30,7 +33,10 @@ export declare class WalletConnect {
     readonly secret: Uint8Array;
     protected readonly signer: EventSigner;
     /** The relays to use for the connection */
-    readonly relays: string[];
+    protected relays$: BehaviorSubject<string[]>;
+    get relays(): string[];
+    /** Whether to accept the relay hint from the wallet service */
+    acceptRelayHint: boolean;
     /** The wallet service public key ( unset if waiting for service ) */
     service$: BehaviorSubject<string | undefined>;
     get service(): string | undefined;
@@ -48,43 +54,65 @@ export declare class WalletConnect {
     protected waitForService$: Observable<string>;
     constructor(options: WalletConnectOptions);
     /** Process response events and return WalletResponse or throw error */
-    protected handleResponseEvent(event: WalletResponseEvent, encryption?: EncryptionMethod): Promise<WalletResponse>;
+    protected handleResponseEvent<Method extends Methods>(event: WalletResponseEvent, encryption?: EncryptionMethod): Promise<Method["response"]>;
     /** Handle notification events */
     protected handleNotificationEvent(event: WalletNotificationEvent): Promise<WalletNotification>;
-    /** Core RPC method that makes a request and returns the response */
-    request(request: WalletRequest, options?: {
+    /** Generic call method with generic type */
+    genericCall<Method extends TWalletMethod>(method: Method["method"], params: Method["request"]["params"], options?: {
         timeout?: number;
-    }): Observable<WalletResponse>;
+    }): Observable<Method["response"] | Method["error"]>;
+    /** Request method with generic type */
+    genericRequest<Method extends TWalletMethod>(method: Method["method"], params: Method["request"]["params"], options?: {
+        timeout?: number;
+    }): Promise<Method["response"]["result"]>;
+    /** Call a method and return an observable of results */
+    call<K extends Methods["method"]>(method: K, params: Extract<Methods, {
+        method: K;
+    }>["request"]["params"], options?: {
+        timeout?: number;
+    }): Observable<Extract<Methods, {
+        method: K;
+    }>["response"] | Extract<Methods, {
+        method: K;
+    }>["error"]>;
+    /** Typed request method, returns the result or throws and error */
+    request<K extends Methods["method"]>(method: K, params: Extract<Methods, {
+        method: K;
+    }>["request"]["params"], options?: {
+        timeout?: number;
+    }): Promise<Extract<Methods, {
+        method: K;
+    }>["response"]["result"]>;
     /**
      * 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;
     /** Gets the nostr+walletauth URI for the connection */
-    getAuthURI(parts?: Omit<WalletAuthURI, "client" | "relays">): string;
+    getAuthURI(parts?: Omit<WalletAuthURI<Methods>, "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 */
-    supportsMethod(method: WalletMethod): Promise<boolean>;
+    supportsMethod(method: string): 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>;
+    payInvoice(invoice: string, amount?: number): Promise<PayInvoiceMethod["response"]["result"]>;
     /** Pay multiple lightning invoices */
     payMultipleInvoices(invoices: Array<{
         id?: string;
         invoice: string;
         amount?: number;
-    }>): Promise<PayInvoiceResult[]>;
+    }>): Promise<MultiPayInvoiceMethod["response"]["result"][]>;
     /** Send a keysend payment */
     payKeysend(pubkey: string, amount: number, preimage?: string, tlv_records?: Array<{
         type: number;
         value: string;
-    }>): Promise<PayKeysendResult>;
+    }>): Promise<PayKeysendMethod["response"]["result"]>;
     /** Send multiple keysend payments */
     payMultipleKeysend(keysends: Array<{
         id?: string;
@@ -95,11 +123,11 @@ export declare class WalletConnect {
             type: number;
             value: string;
         }>;
-    }>): Promise<PayKeysendResult[]>;
+    }>): Promise<MultiPayKeysendMethod["response"]["result"][]>;
     /** Create a new invoice */
-    makeInvoice(amount: number, options?: Omit<MakeInvoiceParams, "amount">): Promise<MakeInvoiceResult>;
+    makeInvoice(amount: number, options?: Omit<MakeInvoiceMethod["request"]["params"], "amount">): Promise<MakeInvoiceMethod["response"]["result"]>;
     /** Look up an invoice by payment hash or invoice string */
-    lookupInvoice(payment_hash?: string, invoice?: string): Promise<LookupInvoiceResult>;
+    lookupInvoice(payment_hash?: string, invoice?: string): Promise<LookupInvoiceMethod["response"]["result"]>;
     /** List transactions */
     listTransactions(params?: {
         from?: number;
@@ -108,15 +136,15 @@ export declare class WalletConnect {
         offset?: number;
         unpaid?: boolean;
         type?: "incoming" | "outgoing";
-    }): Promise<ListTransactionsResult>;
+    }): Promise<ListTransactionsMethod["response"]["result"]>;
     /** Get wallet balance */
-    getBalance(): Promise<GetBalanceResult>;
+    getBalance(): Promise<GetBalanceMethod["response"]["result"]>;
     /** Get wallet info */
-    getInfo(): Promise<GetInfoResult>;
+    getInfo(): Promise<GetInfoMethod["response"]["result"]>;
     /** Serialize the WalletConnect instance */
     toJSON(): SerializedWalletConnect;
     /** Create a new WalletConnect instance from a serialized object */
     static fromJSON(json: SerializedWalletConnect, options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">): WalletConnect;
     /** Create a new WalletConnect instance from a connection string */
-    static fromConnectURI(connectionString: string, options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">): WalletConnect;
+    static fromConnectURI<Methods extends TWalletMethod = CommonWalletMethods>(connectionString: string, options?: Omit<WalletConnectOptions, "secret" | "relays" | "service">): WalletConnect<Methods>;
 }

package/dist/wallet-connect.js

@@ -2,7 +2,7 @@ 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, of, repeat, ReplaySubject, retry, share, switchMap, take, 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, 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";
@@ -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],
@@ -116,6 +122,12 @@ export class WalletConnect {
                 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), 
@@ -145,16 +157,16 @@ export class WalletConnect {
             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(
@@ -170,6 +182,23 @@ export class WalletConnect {
             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
@@ -212,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}`);
@@ -235,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)
@@ -254,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

@@ -2,49 +2,30 @@ import { EventSigner } from "applesauce-factory";
 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, WalletRequestEvent } 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 */
@@ -53,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 */
@@ -71,14 +54,16 @@ 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 */
@@ -91,7 +76,7 @@ export declare class WalletService {
     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 */
@@ -107,13 +92,16 @@ export declare class WalletService {
     /** Handle a wallet request event */
     protected handleRequestEvent(requestEvent: WalletRequestEvent): Promise<void>;
     /** Process a decrypted wallet request */
-    protected processRequest(requestEvent: WalletRequestEvent, 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: WalletRequestEvent, 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: WalletRequestEvent, 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: WalletRequestEvent, 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>;
 }