applesauce-wallet-connect 0.0.0-next-20251009095925 → 0.0.0-next-20251012142625

package/dist/blueprints/request.d.ts

@@ -1,9 +1,9 @@
 import { EventBlueprint } from "applesauce-factory";
-import { WalletRequest } from "../helpers/request.js";
 import { WalletConnectEncryptionMethod } from "../helpers/encryption.js";
+import { TWalletMethod } from "../helpers/methods.js";
 /**
  * Creates a walelt request event
  * @param service - The service pubkey
  * @param request - The request to create an event for
  */
-export declare function WalletRequestBlueprint<TRequest extends WalletRequest>(service: string, request: TRequest, encryption?: WalletConnectEncryptionMethod): EventBlueprint;
+export declare function WalletRequestBlueprint<Method extends TWalletMethod>(service: string, request: Method["request"], encryption?: WalletConnectEncryptionMethod): EventBlueprint;

package/dist/blueprints/response.d.ts

@@ -1,5 +1,5 @@
 import { EventBlueprint } from "applesauce-factory";
 import { NostrEvent } from "nostr-tools";
-import { WalletResponse } from "../helpers/response.js";
+import { TWalletMethod } from "../helpers/methods.js";
 /** Creates a wallet response event */
-export declare function WalletResponseBlueprint(request: NostrEvent, response: WalletResponse): EventBlueprint;
+export declare function WalletResponseBlueprint<Method extends TWalletMethod>(request: NostrEvent, response: Method["response"] | Method["error"]): EventBlueprint;

package/dist/blueprints/support.d.ts

@@ -1,9 +1,10 @@
 import { EventBlueprint } from "applesauce-factory";
 import { WalletSupport } from "../helpers/support.js";
+import { TWalletMethod } from "../helpers/methods.js";
 /**
  * Creates a wallet info event
  * @param info - The wallet support information
  * @param client - The client pubkey
  * @param overrideRelay - An optional relay to tell the client which relay to use (for nostr+walletauth URI connections)
  */
-export declare function WalletSupportBlueprint(info: WalletSupport, client?: string, overrideRelay?: string): EventBlueprint;
+export declare function WalletSupportBlueprint<Methods extends TWalletMethod>(info: WalletSupport<Methods>, client?: string, overrideRelay?: string): EventBlueprint;

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

@@ -1,6 +1,6 @@
 import { NotificationType } from "./notification.js";
-import { WalletMethod } from "./support.js";
-export interface WalletAuthURI {
+import { CommonWalletMethods, TWalletMethod } from "./methods.js";
+export interface WalletAuthURI<Methods extends TWalletMethod = CommonWalletMethods> {
     /** 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 */
@@ -18,7 +18,7 @@ export interface WalletAuthURI {
     /** 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[];
+    methods?: Methods["method"][];
     /** 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) */
@@ -32,13 +32,11 @@ export interface WalletAuthURI {
  * 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;
+export declare function parseWalletAuthURI<Methods extends TWalletMethod = CommonWalletMethods>(authURI: string): WalletAuthURI<Methods>;
+/** Creates a nostr+walletauth URI from a WalletAuthURI object */
+export declare function createWalletAuthURI<Methods extends TWalletMethod = CommonWalletMethods>(parts: WalletAuthURI<Methods>): string;
 /**
  * Validates a WalletAuthURI object
  * @returns true if valid, throws Error if invalid
  */
-export declare function validateWalletAuthURI(parts: WalletAuthURI): boolean;
+export declare function validateWalletAuthURI(parts: WalletAuthURI<TWalletMethod>): boolean;

package/dist/helpers/auth-uri.js

@@ -60,9 +60,7 @@ export function parseWalletAuthURI(authURI) {
         walletName,
     };
 }
-/**
- * Creates a nostr+walletauth URI from a WalletAuthURI object
- */
+/** 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

package/dist/helpers/index.d.ts

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

package/dist/helpers/index.js

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

package/dist/helpers/methods.d.ts

@@ -0,0 +1,234 @@
+import { WalletErrorCode } from "./error.js";
+import { WalletSupport } from "./support.js";
+/** Base request structure for all NIP-47 requests */
+export interface TWalletRequest<Method extends string, Params> {
+    /** The method to call */
+    method: Method;
+    /** Parameters for the method */
+    params: Params;
+}
+/** Error object for wallet responses */
+export interface TWalletResponseError {
+    type: WalletErrorCode;
+    message: string;
+}
+/** Base response structure for all NIP-47 responses */
+export type TWalletErrorResponse<Method extends string> = {
+    /** Indicates the structure of the result field */
+    result_type: Method;
+    /** Error object, non-null in case of error */
+    error: TWalletResponseError;
+    result: null;
+};
+export type TWalletSuccessResponse<Method extends string, Result> = {
+    /** Indicates the structure of the result field */
+    result_type: Method;
+    error: null;
+    /** Result object, null in case of error */
+    result: Result;
+};
+/** Merged wallet response and request types, this is designed to only be used with typescript */
+export type TWalletMethod<Method extends string = string, Params extends any = any, Result extends any = any> = {
+    /** Method string */
+    method: Method;
+    /** Request type */
+    request: TWalletRequest<Method, Params>;
+    /** Response success type */
+    response: TWalletSuccessResponse<Method, Result>;
+    /** Response error type */
+    error: TWalletErrorResponse<Method>;
+};
+/** TLV record for keysend payments */
+export interface TLVRecord {
+    /** TLV type */
+    type: number;
+    /** Hex encoded TLV value */
+    value: string;
+}
+/** Transaction object used in multiple response types */
+export interface Transaction {
+    /** Type of transaction */
+    type: "incoming" | "outgoing";
+    /** State of the transaction */
+    state: "pending" | "settled" | "expired" | "failed";
+    /** Value in msats */
+    amount: number;
+    /** Value in msats */
+    fees_paid: number;
+    /** Invoice/payment creation unix timestamp */
+    created_at: number;
+    /** Encoded invoice, optional */
+    invoice?: string;
+    /** Invoice's description, optional */
+    description?: string;
+    /** Invoice's description hash, optional */
+    description_hash?: string;
+    /** Payment's preimage, optional if unpaid */
+    preimage?: string;
+    /** Payment hash for the payment, optional */
+    payment_hash?: string;
+    /** Invoice expiration unix timestamp, optional if not applicable */
+    expires_at?: number;
+    /** Invoice/payment settlement unix timestamp, optional if unpaid */
+    settled_at?: number;
+    /** Generic metadata that can be used to add things like zap/boostagram details */
+    metadata?: Record<string, any>;
+}
+export type PayInvoiceMethod = TWalletMethod<"pay_invoice", {
+    /** BOLT11 invoice */
+    invoice: string;
+    /** Invoice amount in msats, optional */
+    amount?: number;
+}, {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}>;
+export type MultiPayInvoiceMethod = TWalletMethod<"multi_pay_invoice", {
+    /** Array of invoices to pay */
+    invoices: Array<{
+        /** ID to identify this invoice in the response */
+        id?: string;
+        /** BOLT11 invoice */
+        invoice: string;
+        /** Invoice amount in msats, optional */
+        amount?: number;
+    }>;
+}, {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}>;
+export type PayKeysendMethod = TWalletMethod<"pay_keysend", {
+    /** Amount in msats, required */
+    amount: number;
+    /** Payee pubkey, required */
+    pubkey: string;
+    /** Preimage of the payment, optional */
+    preimage?: string;
+    /** TLV records, optional */
+    tlv_records?: TLVRecord[];
+}, {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}>;
+export type MultiPayKeysendMethod = TWalletMethod<"multi_pay_keysend", {
+    /** Array of keysend payments */
+    keysends: Array<{
+        /** ID to identify this keysend in the response */
+        id?: string;
+        /** Payee pubkey, required */
+        pubkey: string;
+        /** Amount in msats, required */
+        amount: number;
+        /** Preimage of the payment, optional */
+        preimage?: string;
+        /** TLV records, optional */
+        tlv_records?: TLVRecord[];
+    }>;
+}, {
+    /** Preimage of the payment */
+    preimage: string;
+    /** Value in msats, optional */
+    fees_paid?: number;
+}>;
+export type MakeInvoiceMethod = TWalletMethod<"make_invoice", {
+    /** Value in msats */
+    amount: number;
+    /** Invoice's description, optional */
+    description?: string;
+    /** Invoice's description hash, optional */
+    description_hash?: string;
+    /** Expiry in seconds from time invoice is created, optional */
+    expiry?: number;
+}, Transaction>;
+export type LookupInvoiceMethod = TWalletMethod<"lookup_invoice", {
+    /** Payment hash of the invoice, one of payment_hash or invoice is required */
+    payment_hash?: string;
+    /** Invoice to lookup */
+    invoice?: string;
+}, Transaction>;
+export type ListTransactionsMethod = TWalletMethod<"list_transactions", {
+    /** Starting timestamp in seconds since epoch (inclusive), optional */
+    from?: number;
+    /** Ending timestamp in seconds since epoch (inclusive), optional */
+    until?: number;
+    /** Maximum number of invoices to return, optional */
+    limit?: number;
+    /** Offset of the first invoice to return, optional */
+    offset?: number;
+    /** Include unpaid invoices, optional, default false */
+    unpaid?: boolean;
+    /** "incoming" for invoices, "outgoing" for payments, undefined for both */
+    type?: "incoming" | "outgoing";
+}, {
+    /** Array of transactions */
+    transactions: Transaction[];
+}>;
+export type GetBalanceMethod = TWalletMethod<"get_balance", {}, {
+    /** User's balance in msats */
+    balance: number;
+}>;
+/** Type for wallet get_info */
+export type WalletInfo = Omit<WalletSupport, "encryption"> & {
+    /** Node alias */
+    alias?: string;
+    /** Node color as hex string */
+    color?: string;
+    /** Node public key as hex string */
+    pubkey?: string;
+    /** Network type */
+    network?: "mainnet" | "testnet" | "signet" | "regtest";
+    /** Current block height */
+    block_height?: number;
+    /** Current block hash as hex string */
+    block_hash?: string;
+};
+export type GetInfoMethod = TWalletMethod<"get_info", {}, WalletInfo>;
+/** Union type for all wallet method definitions */
+export type CommonWalletMethods = PayInvoiceMethod | MultiPayInvoiceMethod | PayKeysendMethod | MultiPayKeysendMethod | MakeInvoiceMethod | LookupInvoiceMethod | ListTransactionsMethod | GetBalanceMethod | GetInfoMethod;
+/** Withdraw a token from the wallet */
+export type CashuWithdrawMethod = TWalletMethod<"cashu_withdraw", {
+    /** Token amount */
+    amount: number;
+    /** required token unit */
+    unit: string;
+    /** Optional array of mints, if provided token MUST be from one */
+    mints?: string[];
+    /** Size of proofs (optional) */
+    proofs?: number[];
+    /** Lock to pubkey (optional) */
+    p2pk?: string;
+}, {
+    token: string;
+}>;
+/** Deposit a token into the wallet */
+export type CashuDepositMethod = TWalletMethod<"cashu_deposit", {
+    /** Token to deposit */
+    token: string;
+}, {
+    success: true;
+}>;
+export type CashuPayRequestMethod = TWalletMethod<"cashu_pay_request", {
+    /** Cashu payment request. if request originally does not contain an amount they client may add one and re-encode */
+    request: string;
+}, {
+    success: true;
+}>;
+/** Info for a single mint used in the wallet service */
+export type CashuMintInfo = {
+    /** Mint URL */
+    url: string;
+    /** Units and balances */
+    balances: Record<string, number>;
+};
+/** Get the list of mints that are used in the wallet and their balances */
+export type CashuListMintsMethod = TWalletMethod<"cashu_list_mints", {}, {
+    mints: CashuMintInfo[];
+}>;
+/** Union of all cashu methods */
+export type CashuWalletMethods = CashuWithdrawMethod | CashuDepositMethod | CashuPayRequestMethod | CashuListMintsMethod;

package/dist/helpers/methods.js

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

package/dist/helpers/notification.d.ts

@@ -1,6 +1,6 @@
 import { HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
-import { Transaction } from "./response.js";
+import { Transaction } from "./methods.js";
 export declare const WALLET_NOTIFICATION_KIND = 23197;
 export declare const WALLET_LEGACY_NOTIFICATION_KIND = 23196;
 /** A type for validated wallet notification events */

package/dist/helpers/request.d.ts

@@ -1,131 +1,21 @@
 import { HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 import { WalletConnectEncryptionMethod } from "./encryption.js";
-import { WalletMethod } from "./support.js";
+import { TWalletMethod } from "./methods.js";
 export declare const WALLET_REQUEST_KIND = 23194;
 export type WalletRequestEvent = KnownEvent<typeof WALLET_REQUEST_KIND>;
 /** A symbol used to cache the wallet request on the event */
 export declare const WalletRequestSymbol: unique symbol;
 /** Type for events with unlocked hidden content */
-export type UnlockedWalletRequest = UnlockedHiddenContent & {
-    [WalletRequestSymbol]: WalletRequest;
+export type UnlockedWalletRequest<Method extends TWalletMethod = TWalletMethod> = UnlockedHiddenContent & {
+    [WalletRequestSymbol]: Method["request"];
 };
-/** TLV record for keysend payments */
-export interface TLVRecord {
-    /** TLV type */
-    type: number;
-    /** Hex encoded TLV value */
-    value: string;
-}
-/** Base request structure for all NIP-47 requests */
-export interface BaseWalletRequest<TMethod extends WalletMethod, TParams> {
-    /** The method to call */
-    method: TMethod;
-    /** Parameters for the method */
-    params: TParams;
-}
-/** Parameters for pay_invoice method */
-export interface PayInvoiceParams {
-    /** BOLT11 invoice */
-    invoice: string;
-    /** Invoice amount in msats, optional */
-    amount?: number;
-}
-export type PayInvoiceRequest = BaseWalletRequest<"pay_invoice", PayInvoiceParams>;
-/** Parameters for multi_pay_invoice method */
-export interface MultiPayInvoiceParams {
-    /** Array of invoices to pay */
-    invoices: Array<{
-        /** ID to identify this invoice in the response */
-        id?: string;
-        /** BOLT11 invoice */
-        invoice: string;
-        /** Invoice amount in msats, optional */
-        amount?: number;
-    }>;
-}
-export type MultiPayInvoiceRequest = BaseWalletRequest<"multi_pay_invoice", MultiPayInvoiceParams>;
-/** Parameters for pay_keysend method */
-export interface PayKeysendParams {
-    /** Amount in msats, required */
-    amount: number;
-    /** Payee pubkey, required */
-    pubkey: string;
-    /** Preimage of the payment, optional */
-    preimage?: string;
-    /** TLV records, optional */
-    tlv_records?: TLVRecord[];
-}
-export type PayKeysendRequest = BaseWalletRequest<"pay_keysend", PayKeysendParams>;
-/** Parameters for multi_pay_keysend method */
-export interface MultiPayKeysendParams {
-    /** Array of keysend payments */
-    keysends: Array<{
-        /** ID to identify this keysend in the response */
-        id?: string;
-        /** Payee pubkey, required */
-        pubkey: string;
-        /** Amount in msats, required */
-        amount: number;
-        /** Preimage of the payment, optional */
-        preimage?: string;
-        /** TLV records, optional */
-        tlv_records?: TLVRecord[];
-    }>;
-}
-export type MultiPayKeysendRequest = BaseWalletRequest<"multi_pay_keysend", MultiPayKeysendParams>;
-/** Parameters for make_invoice method */
-export interface MakeInvoiceParams {
-    /** Value in msats */
-    amount: number;
-    /** Invoice's description, optional */
-    description?: string;
-    /** Invoice's description hash, optional */
-    description_hash?: string;
-    /** Expiry in seconds from time invoice is created, optional */
-    expiry?: number;
-}
-export type MakeInvoiceRequest = BaseWalletRequest<"make_invoice", MakeInvoiceParams>;
-/** Parameters for lookup_invoice method */
-export interface LookupInvoiceParams {
-    /** Payment hash of the invoice, one of payment_hash or invoice is required */
-    payment_hash?: string;
-    /** Invoice to lookup */
-    invoice?: string;
-}
-export type LookupInvoiceRequest = BaseWalletRequest<"lookup_invoice", LookupInvoiceParams>;
-/** Parameters for list_transactions method */
-export interface ListTransactionsParams {
-    /** Starting timestamp in seconds since epoch (inclusive), optional */
-    from?: number;
-    /** Ending timestamp in seconds since epoch (inclusive), optional */
-    until?: number;
-    /** Maximum number of invoices to return, optional */
-    limit?: number;
-    /** Offset of the first invoice to return, optional */
-    offset?: number;
-    /** Include unpaid invoices, optional, default false */
-    unpaid?: boolean;
-    /** "incoming" for invoices, "outgoing" for payments, undefined for both */
-    type?: "incoming" | "outgoing";
-}
-export type ListTransactionsRequest = BaseWalletRequest<"list_transactions", ListTransactionsParams>;
-/** Parameters for get_balance method */
-export interface GetBalanceParams {
-}
-export type GetBalanceRequest = BaseWalletRequest<"get_balance", GetBalanceParams>;
-/** Parameters for get_info method */
-export interface GetInfoParams {
-}
-export type GetInfoRequest = BaseWalletRequest<"get_info", GetInfoParams>;
-/** Union type for all NIP-47 request types */
-export type WalletRequest = PayInvoiceRequest | MultiPayInvoiceRequest | PayKeysendRequest | MultiPayKeysendRequest | MakeInvoiceRequest | LookupInvoiceRequest | ListTransactionsRequest | GetBalanceRequest | GetInfoRequest;
 /** Checks if a kind 23194 event is locked */
-export declare function isWalletRequestUnlocked(request: any): request is UnlockedWalletRequest;
+export declare function isWalletRequestUnlocked<Method extends TWalletMethod = TWalletMethod>(request: any): request is UnlockedWalletRequest<Method>;
 /** Unlocks a kind 23194 event */
-export declare function unlockWalletRequest(request: NostrEvent, signer: HiddenContentSigner): Promise<WalletRequest | undefined>;
+export declare function unlockWalletRequest<Method extends TWalletMethod = TWalletMethod>(request: NostrEvent, signer: HiddenContentSigner): Promise<Method["request"] | undefined>;
 /** Gets the wallet request from a kind 23194 event */
-export declare function getWalletRequest(request: NostrEvent): WalletRequest | undefined;
+export declare function getWalletRequest<Method extends TWalletMethod = TWalletMethod>(request: NostrEvent): Method["request"] | undefined;
 /** Returns the wallet service pubkey from a request */
 export declare function getWalletRequestServicePubkey(request: WalletRequestEvent): string;
 export declare function getWalletRequestServicePubkey(request: NostrEvent): string | undefined;

package/dist/helpers/response.d.ts

@@ -1,143 +1,21 @@
 import { EncryptionMethod, HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
-import { WalletErrorCode } from "./error.js";
-import { NotificationType } from "./notification.js";
-import { WalletMethod } from "./support.js";
+import { TWalletMethod } from "./methods.js";
 export declare const WALLET_RESPONSE_KIND = 23195;
 /** A symbol used to cache the wallet response on the event */
 export declare const WalletResponseSymbol: unique symbol;
 /** Type for events with unlocked hidden content */
-export type UnlockedWalletResponse = UnlockedHiddenContent & {
-    [WalletResponseSymbol]: WalletResponse;
+export type UnlockedWalletResponse<Method extends TWalletMethod = TWalletMethod> = UnlockedHiddenContent & {
+    [WalletResponseSymbol]: Method["response"];
 };
 /** Type for validated wallet response events */
 export type WalletResponseEvent = KnownEvent<typeof WALLET_RESPONSE_KIND>;
-/** Error object for wallet responses */
-export interface WalletResponseError {
-    type: WalletErrorCode;
-    message: string;
-}
-/** Base response structure for all NIP-47 responses */
-export type BaseWalletResponse<TResultType extends WalletMethod, TResult> = {
-    /** Indicates the structure of the result field */
-    result_type: TResultType;
-    /** Error object, non-null in case of error */
-    error: WalletResponseError;
-    result: null;
-} | {
-    /** Indicates the structure of the result field */
-    result_type: TResultType;
-    error: null;
-    /** Result object, null in case of error */
-    result: TResult;
-};
-/** Transaction object used in multiple response types */
-export interface Transaction {
-    /** Type of transaction */
-    type: "incoming" | "outgoing";
-    /** State of the transaction */
-    state: "pending" | "settled" | "expired" | "failed";
-    /** Value in msats */
-    amount: number;
-    /** Value in msats */
-    fees_paid: number;
-    /** Invoice/payment creation unix timestamp */
-    created_at: number;
-    /** Encoded invoice, optional */
-    invoice?: string;
-    /** Invoice's description, optional */
-    description?: string;
-    /** Invoice's description hash, optional */
-    description_hash?: string;
-    /** Payment's preimage, optional if unpaid */
-    preimage?: string;
-    /** Payment hash for the payment, optional */
-    payment_hash?: string;
-    /** Invoice expiration unix timestamp, optional if not applicable */
-    expires_at?: number;
-    /** Invoice/payment settlement unix timestamp, optional if unpaid */
-    settled_at?: number;
-    /** Generic metadata that can be used to add things like zap/boostagram details */
-    metadata?: Record<string, any>;
-}
-/** Response for pay_invoice method */
-export interface PayInvoiceResult {
-    /** Preimage of the payment */
-    preimage: string;
-    /** Value in msats, optional */
-    fees_paid?: number;
-}
-export type PayInvoiceResponse = BaseWalletResponse<"pay_invoice", PayInvoiceResult>;
-/** Response for multi_pay_invoice method */
-export interface MultiPayInvoiceResult {
-    /** Preimage of the payment */
-    preimage: string;
-    /** Value in msats, optional */
-    fees_paid?: number;
-}
-export type MultiPayInvoiceResponse = BaseWalletResponse<"multi_pay_invoice", MultiPayInvoiceResult>;
-/** Response for pay_keysend method */
-export interface PayKeysendResult {
-    /** Preimage of the payment */
-    preimage: string;
-    /** Value in msats, optional */
-    fees_paid?: number;
-}
-export type PayKeysendResponse = BaseWalletResponse<"pay_keysend", PayKeysendResult>;
-/** Response for multi_pay_keysend method */
-export interface MultiPayKeysendResult {
-    /** Preimage of the payment */
-    preimage: string;
-    /** Value in msats, optional */
-    fees_paid?: number;
-}
-export type MultiPayKeysendResponse = BaseWalletResponse<"multi_pay_keysend", MultiPayKeysendResult>;
-/** Response for make_invoice method */
-export type MakeInvoiceResult = Transaction;
-export type MakeInvoiceResponse = BaseWalletResponse<"make_invoice", MakeInvoiceResult>;
-/** Response for lookup_invoice method */
-export type LookupInvoiceResult = Transaction;
-export type LookupInvoiceResponse = BaseWalletResponse<"lookup_invoice", LookupInvoiceResult>;
-/** Response for list_transactions method */
-export interface ListTransactionsResult {
-    /** Array of transactions */
-    transactions: Transaction[];
-}
-export type ListTransactionsResponse = BaseWalletResponse<"list_transactions", ListTransactionsResult>;
-/** Response for get_balance method */
-export interface GetBalanceResult {
-    /** User's balance in msats */
-    balance: number;
-}
-export type GetBalanceResponse = BaseWalletResponse<"get_balance", GetBalanceResult>;
-/** Response for get_info method */
-export interface GetInfoResult {
-    /** Node alias */
-    alias: string;
-    /** Node color as hex string */
-    color: string;
-    /** Node public key as hex string */
-    pubkey: string;
-    /** Network type */
-    network: "mainnet" | "testnet" | "signet" | "regtest";
-    /** Current block height */
-    block_height: number;
-    /** Current block hash as hex string */
-    block_hash: string;
-    /** List of supported methods for this connection */
-    methods: WalletMethod[];
-    /** List of supported notifications for this connection, optional */
-    notifications?: NotificationType[];
-}
-export type GetInfoResponse = BaseWalletResponse<"get_info", GetInfoResult>;
-/** Union type for all NIP-47 response types */
-export type WalletResponse = PayInvoiceResponse | MultiPayInvoiceResponse | PayKeysendResponse | MultiPayKeysendResponse | MakeInvoiceResponse | LookupInvoiceResponse | ListTransactionsResponse | GetBalanceResponse | GetInfoResponse;
 /** Checks if a kind 23195 event is locked */
-export declare function isWalletResponseUnlocked(response: any): response is UnlockedWalletResponse;
+export declare function isWalletResponseUnlocked<Method extends TWalletMethod = TWalletMethod>(response: any): response is UnlockedWalletResponse<Method>;
 /** Unlocks a kind 23195 event */
-export declare function unlockWalletResponse(response: NostrEvent, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<WalletResponse | undefined>;
+export declare function unlockWalletResponse<Method extends TWalletMethod = TWalletMethod>(response: NostrEvent, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<Method["response"] | undefined>;
 /** Gets the wallet response from a kind 23195 event */
-export declare function getWalletResponse(response: NostrEvent): WalletResponse | undefined;
+export declare function getWalletResponse<Method extends TWalletMethod = TWalletMethod>(response: NostrEvent): Method["response"] | undefined;
 /** Returns the client pubkey of client this response is for */
 export declare function getWalletResponseClientPubkey(response: WalletResponseEvent): string;
 export declare function getWalletResponseClientPubkey(response: NostrEvent): string | undefined;

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 & {
@@ -17,7 +18,7 @@ export type WalletConnectOptions = NostrConnectionMethodsOptions & {
     /** 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 */
@@ -53,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;
@@ -100,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;
@@ -113,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

@@ -157,8 +157,8 @@ 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 event
@@ -166,7 +166,7 @@ export class WalletConnect {
             // 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(
@@ -182,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
@@ -224,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}`);
@@ -247,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)
@@ -266,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,16 +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"> & {
+    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;
+    }): WalletService<Methods>;
 }

package/dist/wallet-service.js

@@ -7,7 +7,7 @@ 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 { 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 */
@@ -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 */
@@ -164,7 +166,7 @@ export class WalletService {
         try {
             // 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 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);
         }
@@ -194,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);
@@ -275,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);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-wallet-connect",
-  "version": "0.0.0-next-20251009095925",
+  "version": "0.0.0-next-20251012142625",
   "description": "",
   "type": "module",
   "main": "dist/index.js",