applesauce-wallet-connect 3.1.0 → 4.1.0

package/dist/helpers/response.d.ts

@@ -1,138 +1,26 @@
-import { EncryptionMethod, HiddenContentSigner } from "applesauce-core/helpers";
+import { EncryptionMethod, HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
-import { WalletErrorCode } from "./error.js";
-import { WalletMethod } from "./support.js";
-import { NotificationType } from "./notification.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;
-/** 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;
+/** Type for events with unlocked hidden content */
+export type UnlockedWalletResponse<Method extends TWalletMethod = TWalletMethod> = UnlockedHiddenContent & {
+    [WalletResponseSymbol]: Method["response"];
 };
-/** 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;
+/** Type for validated wallet response events */
+export type WalletResponseEvent = KnownEvent<typeof WALLET_RESPONSE_KIND>;
 /** Checks if a kind 23195 event is locked */
-export declare function isWalletResponseLocked(response: NostrEvent): boolean;
+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 | null>;
+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 | null;
+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;
 /** Returns the request id of the request this response is for */
+export declare function getWalletResponseRequestId(response: WalletResponseEvent): string;
 export declare function getWalletResponseRequestId(response: NostrEvent): string | undefined;
+/** Checks if event is a valid wallet response event */
+export declare function isValidWalletResponse(response: NostrEvent): response is WalletResponseEvent;

package/dist/helpers/response.js

@@ -1,35 +1,41 @@
-import { getHiddenContent, getOrComputeCachedValue, getTagValue, isHiddenContentLocked, isNIP04Encrypted, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+import { getTagValue, isHiddenContentUnlocked, isNIP04Encrypted, notifyEventUpdate, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
 export const WALLET_RESPONSE_KIND = 23195;
 // Set the encryption method to use for response kind
 setHiddenContentEncryptionMethod(WALLET_RESPONSE_KIND, "nip04");
 /** A symbol used to cache the wallet response on the event */
 export const WalletResponseSymbol = Symbol("wallet-response");
 /** Checks if a kind 23195 event is locked */
-export function isWalletResponseLocked(response) {
-    return isHiddenContentLocked(response);
+export function isWalletResponseUnlocked(response) {
+    return isHiddenContentUnlocked(response) && Reflect.has(response, WalletResponseSymbol) === true;
 }
 /** Unlocks a kind 23195 event */
 export async function unlockWalletResponse(response, signer, override) {
+    if (isWalletResponseUnlocked(response))
+        return response[WalletResponseSymbol];
     const encryption = override ?? (!isNIP04Encrypted(response.content) ? "nip44" : "nip04");
-    await unlockHiddenContent(response, signer, encryption);
-    return getWalletResponse(response);
+    const content = await unlockHiddenContent(response, signer, encryption);
+    const parsed = JSON.parse(content);
+    // Save the parsed content
+    Reflect.set(response, WalletResponseSymbol, parsed);
+    notifyEventUpdate(response);
+    return parsed;
 }
 /** Gets the wallet response from a kind 23195 event */
 export function getWalletResponse(response) {
-    if (isWalletResponseLocked(response))
+    if (isWalletResponseUnlocked(response))
+        return response[WalletResponseSymbol];
+    else
         return undefined;
-    return getOrComputeCachedValue(response, WalletResponseSymbol, () => {
-        const content = getHiddenContent(response);
-        if (!content)
-            return null;
-        return JSON.parse(content);
-    });
 }
-/** Returns the client pubkey of client this response is for */
 export function getWalletResponseClientPubkey(response) {
     return getTagValue(response, "p");
 }
-/** Returns the request id of the request this response is for */
 export function getWalletResponseRequestId(response) {
     return getTagValue(response, "e");
 }
+/** Checks if event is a valid wallet response event */
+export function isValidWalletResponse(response) {
+    return (response.kind === WALLET_RESPONSE_KIND &&
+        getWalletResponseRequestId(response) !== undefined &&
+        getWalletResponseClientPubkey(response) !== 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, WalletRequest, WalletResponse, 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: NostrEvent, encryption?: EncryptionMethod): Promise<WalletResponse>;
+    protected handleResponseEvent<Method extends Methods>(event: WalletResponseEvent, encryption?: EncryptionMethod): Promise<Method["response"]>;
     /** Handle notification events */
-    protected handleNotificationEvent(event: NostrEvent): Promise<WalletNotification>;
-    /** Core RPC method that makes a request and returns the response */
-    request(request: WalletRequest, options?: {
+    protected handleNotificationEvent(event: WalletNotificationEvent): Promise<WalletNotification>;
+    /** 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>;
 }