applesauce-wallet-connect 4.0.0 → 4.1.0

package/README.md

@@ -41,10 +41,10 @@ Create a wallet service that handles NIP-47 requests:
 
 ```typescript
 import { WalletService } from "applesauce-wallet-connect";
-import { SimpleSigner } from "applesauce-signers";
+import { PrivateKeySigner } from "applesauce-signers";
 
 // Create a signer for the service
-const signer = new SimpleSigner();
+const signer = new PrivateKeySigner();
 
 // Define method handlers
 const handlers = {

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,4 +1,10 @@
 import { EventBlueprint } from "applesauce-factory";
 import { WalletSupport } from "../helpers/support.js";
-/** Creates a wallet info event */
-export declare function WalletSupportBlueprint(info: WalletSupport, client?: string): EventBlueprint;
+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<Methods extends TWalletMethod>(info: WalletSupport<Methods>, client?: string, overrideRelay?: string): EventBlueprint;

package/dist/blueprints/support.js

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

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;