applesauce-wallet-connect 3.0.0 → 4.0.0

package/dist/helpers/notification.d.ts

@@ -1,10 +1,16 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
+import { HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 import { Transaction } from "./response.js";
 export declare const WALLET_NOTIFICATION_KIND = 23197;
 export declare const WALLET_LEGACY_NOTIFICATION_KIND = 23196;
+/** A type for validated wallet notification events */
+export type WalletNotificationEvent = KnownEvent<typeof WALLET_NOTIFICATION_KIND> | KnownEvent<typeof WALLET_LEGACY_NOTIFICATION_KIND>;
 /** A symbol used to cache the wallet notification on the event */
 export declare const WalletNotificationSymbol: unique symbol;
+/** A type for unlocked notifications events */
+export type UnlockedWalletNotification = UnlockedHiddenContent & {
+    [WalletNotificationSymbol]: WalletNotification;
+};
 /** Supported notification types */
 export type NotificationType = "payment_received" | "payment_sent";
 /** Base notification structure */
@@ -21,8 +27,10 @@ export type PaymentSentNotification = BaseNotification<"payment_sent", Transacti
 /** Union type for all NIP-47 notification types */
 export type WalletNotification = PaymentReceivedNotification | PaymentSentNotification;
 /** Checks if a kind 23196 or 23197 event is locked */
-export declare function isWalletNotificationLocked(notification: NostrEvent): boolean;
+export declare function isWalletNotificationUnlocked(notification: any): notification is UnlockedWalletNotification;
 /** Unlocks a kind 23196 or 23197 event */
-export declare function unlockWalletNotification(notification: NostrEvent, signer: HiddenContentSigner): Promise<WalletNotification | undefined | null>;
+export declare function unlockWalletNotification(notification: NostrEvent, signer: HiddenContentSigner): Promise<WalletNotification | undefined>;
 /** Gets the wallet notification from a kind 23196 or 23197 event */
-export declare function getWalletNotification(notification: NostrEvent): WalletNotification | undefined | null;
+export declare function getWalletNotification(notification: NostrEvent): WalletNotification | undefined;
+/** Checks if an event is a valid wallet notification event */
+export declare function isValidWalletNotification(notification: NostrEvent): notification is WalletNotificationEvent;

package/dist/helpers/notification.js

@@ -1,4 +1,4 @@
-import { getHiddenContent, getOrComputeCachedValue, isHiddenContentLocked, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
+import { isHiddenContentUnlocked, notifyEventUpdate, setHiddenContentEncryptionMethod, unlockHiddenContent, } from "applesauce-core/helpers";
 export const WALLET_NOTIFICATION_KIND = 23197;
 export const WALLET_LEGACY_NOTIFICATION_KIND = 23196;
 /** A symbol used to cache the wallet notification on the event */
@@ -7,22 +7,28 @@ export const WalletNotificationSymbol = Symbol("wallet-notification");
 setHiddenContentEncryptionMethod(WALLET_NOTIFICATION_KIND, "nip44");
 setHiddenContentEncryptionMethod(WALLET_LEGACY_NOTIFICATION_KIND, "nip04");
 /** Checks if a kind 23196 or 23197 event is locked */
-export function isWalletNotificationLocked(notification) {
-    return isHiddenContentLocked(notification);
+export function isWalletNotificationUnlocked(notification) {
+    return isHiddenContentUnlocked(notification) && Reflect.has(notification, WalletNotificationSymbol) === true;
 }
 /** Unlocks a kind 23196 or 23197 event */
 export async function unlockWalletNotification(notification, signer) {
-    await unlockHiddenContent(notification, signer);
-    return getWalletNotification(notification);
+    if (isWalletNotificationUnlocked(notification))
+        return notification[WalletNotificationSymbol];
+    const content = await unlockHiddenContent(notification, signer);
+    const parsed = JSON.parse(content);
+    // Save the parsed content
+    Reflect.set(notification, WalletNotificationSymbol, parsed);
+    notifyEventUpdate(notification);
+    return parsed;
 }
 /** Gets the wallet notification from a kind 23196 or 23197 event */
 export function getWalletNotification(notification) {
-    if (isWalletNotificationLocked(notification))
+    if (isWalletNotificationUnlocked(notification))
+        return notification[WalletNotificationSymbol];
+    else
         return undefined;
-    return getOrComputeCachedValue(notification, WalletNotificationSymbol, () => {
-        const content = getHiddenContent(notification);
-        if (!content)
-            return null;
-        return JSON.parse(content);
-    });
+}
+/** Checks if an event is a valid wallet notification event */
+export function isValidWalletNotification(notification) {
+    return notification.kind === WALLET_NOTIFICATION_KIND || notification.kind === WALLET_LEGACY_NOTIFICATION_KIND;
 }

package/dist/helpers/request.d.ts

@@ -1,10 +1,15 @@
-import { HiddenContentSigner } from "applesauce-core/helpers";
+import { HiddenContentSigner, KnownEvent, UnlockedHiddenContent } from "applesauce-core/helpers";
 import { NostrEvent } from "nostr-tools";
 import { WalletConnectEncryptionMethod } from "./encryption.js";
 import { WalletMethod } from "./support.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;
+};
 /** TLV record for keysend payments */
 export interface TLVRecord {
     /** TLV type */
@@ -116,12 +121,13 @@ 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 isWalletRequestLocked(request: NostrEvent): boolean;
+export declare function isWalletRequestUnlocked(request: any): request is UnlockedWalletRequest;
 /** Unlocks a kind 23194 event */
-export declare function unlockWalletRequest(request: NostrEvent, signer: HiddenContentSigner): Promise<WalletRequest | undefined | null>;
+export declare function unlockWalletRequest(request: NostrEvent, signer: HiddenContentSigner): Promise<WalletRequest | undefined>;
 /** Gets the wallet request from a kind 23194 event */
-export declare function getWalletRequest(request: NostrEvent): WalletRequest | undefined | null;
+export declare function getWalletRequest(request: NostrEvent): WalletRequest | undefined;
 /** Returns the wallet service pubkey from a request */
+export declare function getWalletRequestServicePubkey(request: WalletRequestEvent): string;
 export declare function getWalletRequestServicePubkey(request: NostrEvent): string | undefined;
 /** Returns the expiration timestamp from a request */
 export declare function getWalletRequestExpiration(request: NostrEvent): number | undefined;
@@ -129,3 +135,5 @@ export declare function getWalletRequestExpiration(request: NostrEvent): number
 export declare function isWalletRequestExpired(request: NostrEvent): boolean;
 /** Gets the encryption method used for a request */
 export declare function getWalletRequestEncryption(request: NostrEvent): WalletConnectEncryptionMethod;
+/** Checks if an event is a valid wallet request event */
+export declare function isValidWalletRequest(request: NostrEvent): request is WalletRequestEvent;

package/dist/helpers/request.js

@@ -1,30 +1,31 @@
-import { getHiddenContent, getOrComputeCachedValue, getTagValue, isHiddenContentLocked, isNIP04Encrypted, setHiddenContentEncryptionMethod, unixNow, unlockHiddenContent, } from "applesauce-core/helpers";
+import { getTagValue, isHiddenContentUnlocked, isNIP04Encrypted, notifyEventUpdate, setHiddenContentEncryptionMethod, unixNow, unlockHiddenContent, } from "applesauce-core/helpers";
 export const WALLET_REQUEST_KIND = 23194;
 // Set the encryption method to use for request kind
 setHiddenContentEncryptionMethod(WALLET_REQUEST_KIND, "nip44");
 /** A symbol used to cache the wallet request on the event */
 export const WalletRequestSymbol = Symbol("wallet-request");
 /** Checks if a kind 23194 event is locked */
-export function isWalletRequestLocked(request) {
-    return isHiddenContentLocked(request);
+export function isWalletRequestUnlocked(request) {
+    return isHiddenContentUnlocked(request) && Reflect.has(request, WalletRequestSymbol) === true;
 }
 /** Unlocks a kind 23194 event */
 export async function unlockWalletRequest(request, signer) {
-    await unlockHiddenContent(request, signer);
-    return getWalletRequest(request);
+    if (isWalletRequestUnlocked(request))
+        return request[WalletRequestSymbol];
+    const content = await unlockHiddenContent(request, signer);
+    const parsed = JSON.parse(content);
+    // Save the parsed content
+    Reflect.set(request, WalletRequestSymbol, parsed);
+    notifyEventUpdate(request);
+    return parsed;
 }
 /** Gets the wallet request from a kind 23194 event */
 export function getWalletRequest(request) {
-    if (isWalletRequestLocked(request))
+    if (isWalletRequestUnlocked(request))
+        return request[WalletRequestSymbol];
+    else
         return undefined;
-    return getOrComputeCachedValue(request, WalletRequestSymbol, () => {
-        const content = getHiddenContent(request);
-        if (!content)
-            return null;
-        return JSON.parse(content);
-    });
-}
-/** Returns the wallet service pubkey from a request */
+}
 export function getWalletRequestServicePubkey(request) {
     return getTagValue(request, "p");
 }
@@ -49,3 +50,7 @@ export function getWalletRequestEncryption(request) {
             ? "nip04"
             : "nip44_v2";
 }
+/** Checks if an event is a valid wallet request event */
+export function isValidWalletRequest(request) {
+    return request.kind === WALLET_REQUEST_KIND && getWalletRequestServicePubkey(request) !== undefined;
+}

package/dist/helpers/response.d.ts

@@ -1,11 +1,17 @@
-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 { WalletMethod } from "./support.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;
+};
+/** Type for validated wallet response events */
+export type WalletResponseEvent = KnownEvent<typeof WALLET_RESPONSE_KIND>;
 /** Error object for wallet responses */
 export interface WalletResponseError {
     type: WalletErrorCode;
@@ -127,12 +133,16 @@ 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 isWalletResponseLocked(response: NostrEvent): boolean;
+export declare function isWalletResponseUnlocked(response: any): response is UnlockedWalletResponse;
 /** Unlocks a kind 23195 event */
-export declare function unlockWalletResponse(response: NostrEvent, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<WalletResponse | undefined | null>;
+export declare function unlockWalletResponse(response: NostrEvent, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<WalletResponse | undefined>;
 /** Gets the wallet response from a kind 23195 event */
-export declare function getWalletResponse(response: NostrEvent): WalletResponse | undefined | null;
+export declare function getWalletResponse(response: NostrEvent): WalletResponse | 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/index.d.ts

@@ -2,4 +2,4 @@ export * as Blueprints from "./blueprints/index.js";
 export * as Helpers from "./helpers/index.js";
 export * from "./wallet-connect.js";
 export * from "./wallet-service.js";
-export * from "./types.js";
+export * from "./interop.js";

package/dist/index.js

@@ -2,4 +2,4 @@ export * as Blueprints from "./blueprints/index.js";
 export * as Helpers from "./helpers/index.js";
 export * from "./wallet-connect.js";
 export * from "./wallet-service.js";
-export * from "./types.js";
+export * from "./interop.js";

package/dist/interop.d.ts

@@ -0,0 +1,35 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { ObservableInput } from "rxjs";
+/** A method used to subscribe to events on a set of relays */
+export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => ObservableInput<NostrEvent | string>;
+/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
+export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | ObservableInput<any>;
+/** A simple pool type that combines the subscription and publish methods */
+export type NostrPool = {
+    subscription: NostrSubscriptionMethod;
+    publish: NostrPublishMethod;
+};
+/** Options for setting the subscription and publish methods */
+export type NostrConnectionMethodsOptions = {
+    /** An optional method for subscribing to relays */
+    subscriptionMethod?: NostrSubscriptionMethod;
+    /** An optional method for publishing events */
+    publishMethod?: NostrPublishMethod;
+    /** An optional pool for connection methods */
+    pool?: NostrPool;
+};
+/** A class that implements has global fallback methods for subscription and publish methods */
+export interface NostrConnectionClassMethods {
+    new (...args: any[]): any;
+    /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
+    subscriptionMethod: NostrSubscriptionMethod | undefined;
+    /** A fallback method to use for publishMethod if none is passed in when creating the client */
+    publishMethod: NostrPublishMethod | undefined;
+    /** A fallback pool to use if none is pass in when creating the signer */
+    pool: NostrPool | undefined;
+}
+/** Get the subscription and publish methods for a NostrConnect class */
+export declare function getConnectionMethods(options: NostrConnectionMethodsOptions, cls?: NostrConnectionClassMethods): {
+    subscriptionMethod: NostrSubscriptionMethod;
+    publishMethod: NostrPublishMethod;
+};

package/dist/interop.js

@@ -0,0 +1,19 @@
+/** Get the subscription and publish methods for a NostrConnect class */
+export function getConnectionMethods(options, cls) {
+    const subscriptionMethod = options.subscriptionMethod ||
+        options.pool?.subscription.bind(options.pool) ||
+        cls?.subscriptionMethod ||
+        cls?.pool?.subscription.bind(cls.pool);
+    if (!subscriptionMethod)
+        throw new Error("Missing subscriptionMethod, either pass a method or set subscriptionMethod globally on the class");
+    const publishMethod = options.publishMethod ||
+        options.pool?.publish.bind(options.pool) ||
+        cls?.publishMethod ||
+        cls?.pool?.publish.bind(cls.pool);
+    if (!publishMethod)
+        throw new Error("Missing publishMethod, either pass a method or set publishMethod globally on the class");
+    return {
+        subscriptionMethod,
+        publishMethod,
+    };
+}

package/dist/wallet-connect.d.ts

@@ -2,10 +2,10 @@ 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 { NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
+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 { NostrConnectionMethodsOptions, NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./interop.js";
 export type SerializedWalletConnect = WalletConnectURI;
-export type WalletConnectOptions = {
+export type WalletConnectOptions = NostrConnectionMethodsOptions & {
     /** The secret to use for the connection */
     secret: Uint8Array;
     /** The relays to use for the connection */
@@ -14,12 +14,6 @@ export type WalletConnectOptions = {
     service?: string;
     /** Default timeout for RPC requests in milliseconds */
     timeout?: number;
-    /** A method for subscribing to relays */
-    subscriptionMethod?: NostrSubscriptionMethod;
-    /** A method for publishing events */
-    publishMethod?: NostrPublishMethod;
-    /** An optional pool for connection methods */
-    pool?: NostrPool;
 };
 export declare class WalletConnect {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
@@ -54,9 +48,9 @@ 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(event: WalletResponseEvent, encryption?: EncryptionMethod): Promise<WalletResponse>;
     /** Handle notification events */
-    protected handleNotificationEvent(event: NostrEvent): Promise<WalletNotification>;
+    protected handleNotificationEvent(event: WalletNotificationEvent): Promise<WalletNotification>;
     /** Core RPC method that makes a request and returns the response */
     request(request: WalletRequest, options?: {
         timeout?: number;

package/dist/wallet-connect.js

@@ -2,10 +2,11 @@ import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { simpleTimeout } from "applesauce-core";
 import { create } from "applesauce-factory";
 import { finalizeEvent, getPublicKey, nip04, nip44, verifyEvent } from "nostr-tools";
-import { BehaviorSubject, defer, filter, firstValueFrom, from, fromEvent, identity, ignoreElements, lastValueFrom, map, merge, mergeMap, ReplaySubject, share, switchMap, takeUntil, tap, timer, toArray, } from "rxjs";
+import { BehaviorSubject, defer, filter, firstValueFrom, from, fromEvent, identity, ignoreElements, lastValueFrom, map, merge, mergeMap, of, repeat, ReplaySubject, retry, share, switchMap, take, takeUntil, tap, timer, toArray, } from "rxjs";
 import { WalletRequestBlueprint } from "./blueprints/index.js";
 import { createWalletError } from "./helpers/error.js";
-import { createWalletAuthURI, getPreferredEncryption, getWalletNotification, getWalletRequestEncryption, getWalletResponse, getWalletResponseRequestId, getWalletSupport, isWalletNotificationLocked, isWalletResponseLocked, parseWalletConnectURI, supportsMethod, supportsNotifications, supportsNotificationType, unlockWalletNotification, unlockWalletResponse, WALLET_INFO_KIND, WALLET_LEGACY_NOTIFICATION_KIND, WALLET_NOTIFICATION_KIND, WALLET_RESPONSE_KIND, } from "./helpers/index.js";
+import { createWalletAuthURI, getPreferredEncryption, getWalletRequestEncryption, getWalletResponseRequestId, getWalletSupport, isValidWalletNotification, isValidWalletResponse, parseWalletConnectURI, supportsMethod, supportsNotifications, supportsNotificationType, unlockWalletNotification, unlockWalletResponse, WALLET_INFO_KIND, WALLET_LEGACY_NOTIFICATION_KIND, WALLET_NOTIFICATION_KIND, WALLET_RESPONSE_KIND, } from "./helpers/index.js";
+import { getConnectionMethods, } from "./interop.js";
 export class WalletConnect {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
     static subscriptionMethod = undefined;
@@ -58,15 +59,7 @@ export class WalletConnect {
             },
         };
         // Get the subscription and publish methods
-        const subscriptionMethod = options.subscriptionMethod ||
-            options.pool?.subscription ||
-            WalletConnect.subscriptionMethod ||
-            WalletConnect.pool?.subscription;
-        if (!subscriptionMethod)
-            throw new Error("Missing subscriptionMethod, either pass a method or set WalletConnect.subscriptionMethod");
-        const publishMethod = options.publishMethod || options.pool?.publish || WalletConnect.publishMethod || WalletConnect.pool?.publish;
-        if (!publishMethod)
-            throw new Error("Missing publishMethod, either pass a method or set WalletConnect.publishMethod");
+        const { subscriptionMethod, publishMethod } = getConnectionMethods(options, WalletConnect);
         // Use arrow functions so "this" isn't bound to the signer
         this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
         this.publishMethod = (relays, event) => publishMethod(relays, event);
@@ -75,10 +68,14 @@ export class WalletConnect {
             const client = getPublicKey(this.secret);
             // If the service is not known yet, subscribe to a wallet info event tagging the client
             if (!service)
-                return this.subscriptionMethod(this.relays, [{ kinds: [WALLET_INFO_KIND], "#p": [client] }]).pipe(
+                return from(this.subscriptionMethod(this.relays, [{ kinds: [WALLET_INFO_KIND], "#p": [client] }])).pipe(
+                // Keep the connection open indefinitely
+                repeat(), 
+                // Retry on connection failure
+                retry(), 
                 // Ignore strings (support for applesauce-relay)
                 filter((event) => typeof event !== "string"));
-            return this.subscriptionMethod(this.relays, [
+            return from(this.subscriptionMethod(this.relays, [
                 // Subscribe to response events
                 {
                     kinds: [WALLET_RESPONSE_KIND, WALLET_NOTIFICATION_KIND, WALLET_LEGACY_NOTIFICATION_KIND],
@@ -87,7 +84,11 @@ export class WalletConnect {
                 },
                 // Subscribe to wallet info events
                 { kinds: [WALLET_INFO_KIND], authors: [service] },
-            ]).pipe(
+            ])).pipe(
+            // Keep the connection open indefinitely
+            repeat(), 
+            // Retry on connection failure
+            retry(), 
             // Ignore strings (support for applesauce-relay)
             filter((event) => typeof event !== "string"), 
             // Only include events from the wallet service
@@ -102,19 +103,24 @@ export class WalletConnect {
             resetOnRefCountZero: () => timer(60000), // Keep info observable around for 1 minute after last unsubscribe
         }));
         this.encryption$ = this.support$.pipe(map((info) => (info ? getPreferredEncryption(info) : "nip04")));
-        this.notifications$ = this.events$.pipe(filter((event) => event.kind === WALLET_NOTIFICATION_KIND), mergeMap((event) => this.handleNotificationEvent(event)));
-        this.waitForService$ = this.events$.pipe(
-        // Complete when the service is set
-        takeUntil(this.service$), 
-        // Only listen for wallet info events
-        filter((event) => event.kind === WALLET_INFO_KIND && !this.service), 
-        // Set the service to the pubkey of the wallet info event
-        tap((event) => {
-            // Set the service to the pubkey of the wallet info event
-            this.service$.next(event.pubkey);
-        }), 
-        // Get the service pubkey from the event
-        map((event) => event.pubkey), 
+        this.notifications$ = this.events$.pipe(filter((event) => isValidWalletNotification(event)), mergeMap((event) => this.handleNotificationEvent(event)));
+        this.waitForService$ = defer(() => 
+        // If service is already set, return it
+        this.service$.value
+            ? of(this.service$.value)
+            : // Otherwise listen for new wallet info events
+                this.events$.pipe(
+                // Only listen for wallet info events
+                filter((event) => event.kind === WALLET_INFO_KIND), 
+                // Set the service to the pubkey of the wallet info event
+                tap((event) => {
+                    // Set the service to the pubkey of the wallet info event
+                    this.service$.next(event.pubkey);
+                }), 
+                // Get the service pubkey from the event
+                map((event) => event.pubkey), 
+                // Complete after the first value
+                take(1))).pipe(
         // Only create a single subscription to avoid multiple side effects
         share());
     }
@@ -125,11 +131,7 @@ export class WalletConnect {
         const requestId = getWalletResponseRequestId(event);
         if (!requestId)
             throw new Error("Response missing request ID");
-        let response;
-        if (isWalletResponseLocked(event))
-            response = await unlockWalletResponse(event, this.signer, encryption);
-        else
-            response = getWalletResponse(event);
+        const response = await unlockWalletResponse(event, this.signer, encryption);
         if (!response)
             throw new Error("Failed to decrypt or parse response");
         return response;
@@ -138,11 +140,7 @@ export class WalletConnect {
     async handleNotificationEvent(event) {
         if (!verifyEvent(event))
             throw new Error("Invalid notification event signature");
-        let notification;
-        if (isWalletNotificationLocked(event))
-            notification = await unlockWalletNotification(event, this.signer);
-        else
-            notification = getWalletNotification(event);
+        const notification = await unlockWalletNotification(event, this.signer);
         if (!notification)
             throw new Error("Failed to decrypt or parse notification");
         return notification;
@@ -166,7 +164,7 @@ export class WalletConnect {
             // Create an observable that publishes the request event when subscribed to
             const request$ = defer(() => from(this.publishMethod(this.relays, requestEvent))).pipe(ignoreElements());
             // Create an observable that listens for response events
-            const responses$ = this.events$.pipe(filter((response) => response.kind === WALLET_RESPONSE_KIND && getWalletResponseRequestId(response) === requestEvent.id), mergeMap((response) => this.handleResponseEvent(response, encryption)), 
+            const responses$ = this.events$.pipe(filter(isValidWalletResponse), filter((response) => getWalletResponseRequestId(response) === requestEvent.id), mergeMap((response) => this.handleResponseEvent(response, encryption)), 
             // Set timeout for response events
             simpleTimeout(options.timeout || this.defaultTimeout));
             return merge(request$, responses$);

package/dist/wallet-service.d.ts

@@ -1,13 +1,12 @@
 import { EventSigner } from "applesauce-factory";
-import { NostrEvent } from "nostr-tools";
 import { Observable, Subscription } from "rxjs";
+import { WalletAuthURI } from "./helpers/auth-uri.js";
 import { WalletErrorCode } from "./helpers/error.js";
 import { NotificationType, WalletNotification } from "./helpers/notification.js";
-import { GetBalanceParams, GetInfoParams, ListTransactionsParams, LookupInvoiceParams, MakeInvoiceParams, MultiPayInvoiceParams, MultiPayKeysendParams, PayInvoiceParams, PayKeysendParams, WalletRequest } from "./helpers/request.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 { WalletSupport } from "./helpers/support.js";
-import { NostrPool, NostrPublishMethod, NostrSubscriptionMethod } from "./types.js";
-import { WalletAuthURI } from "./helpers/auth-uri.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 */
@@ -45,7 +44,7 @@ export type SerializedWalletService = {
     relays: string[];
 };
 /** Options for creating a WalletService */
-export interface WalletServiceOptions {
+export interface WalletServiceOptions extends NostrConnectionMethodsOptions {
     /** The relays to use for the service */
     relays: string[];
     /** The signer to use for creating and unlocking events */
@@ -58,12 +57,6 @@ export interface WalletServiceOptions {
     handlers: WalletServiceHandlers;
     /** An array of notifications this wallet supports */
     notifications?: NotificationType[];
-    /** An optional method for subscribing to relays */
-    subscriptionMethod?: NostrSubscriptionMethod;
-    /** An optional method for publishing events */
-    publishMethod?: NostrPublishMethod;
-    /** An optional pool for connection methods */
-    pool?: NostrPool;
 }
 /** NIP-47 Wallet Service implementation */
 export declare class WalletService {
@@ -89,11 +82,11 @@ export declare class WalletService {
     /** The service's public key */
     pubkey: string | null;
     /** The client's secret key */
-    protected secret: Uint8Array;
+    protected secret?: Uint8Array;
     /** The client's public key */
     client: string;
     /** Shared observable for all wallet request events */
-    protected events$: Observable<NostrEvent> | null;
+    protected events$: Observable<WalletRequestEvent> | null;
     /** Subscription to the events observable */
     protected subscription: Subscription | null;
     /** Whether the service is currently running */
@@ -112,15 +105,15 @@ export declare class WalletService {
     /** Publish the wallet support event */
     protected publishSupportEvent(): Promise<void>;
     /** Handle a wallet request event */
-    protected handleRequestEvent(requestEvent: NostrEvent): Promise<void>;
+    protected handleRequestEvent(requestEvent: WalletRequestEvent): Promise<void>;
     /** Process a decrypted wallet request */
-    protected processRequest(requestEvent: NostrEvent, request: WalletRequest): Promise<void>;
+    protected processRequest(requestEvent: WalletRequestEvent, request: WalletRequest): Promise<void>;
     /** Send a success response */
-    protected sendSuccessResponse<T extends WalletResponse>(requestEvent: NostrEvent, method: T["result_type"], result: T["result"]): Promise<void>;
+    protected sendSuccessResponse<T extends WalletResponse>(requestEvent: WalletRequestEvent, method: T["result_type"], result: T["result"]): Promise<void>;
     /** Send an error response */
-    protected sendErrorResponse(requestEvent: NostrEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
+    protected sendErrorResponse(requestEvent: WalletRequestEvent, errorType: WalletErrorCode, errorMessage: string): Promise<void>;
     /** Send a response event */
-    protected sendResponse(requestEvent: NostrEvent, response: WalletResponse): Promise<void>;
+    protected sendResponse(requestEvent: WalletRequestEvent, response: WalletResponse): Promise<void>;
     /** Creates a service for a nostr+walletauth URI */
     static fromAuthURI(uri: string | WalletAuthURI, options: Omit<WalletServiceOptions, "relays">): WalletService;
 }

package/dist/wallet-service.js

@@ -1,14 +1,15 @@
 import { logger } from "applesauce-core";
 import { create } from "applesauce-factory";
 import { generateSecretKey, getPublicKey, verifyEvent } from "nostr-tools";
-import { filter, mergeMap, share } from "rxjs";
+import { filter, from, mergeMap, repeat, retry, share } from "rxjs";
+import { bytesToHex } from "@noble/hashes/utils";
 import { WalletLegacyNotificationBlueprint, WalletNotificationBlueprint } from "./blueprints/notification.js";
 import { WalletResponseBlueprint } from "./blueprints/response.js";
 import { WalletSupportBlueprint } from "./blueprints/support.js";
-import { WalletBaseError } from "./helpers/error.js";
-import { getWalletRequest, isWalletRequestExpired, isWalletRequestLocked, unlockWalletRequest, WALLET_REQUEST_KIND, } from "./helpers/request.js";
-import { bytesToHex } from "@noble/hashes/utils";
 import { parseWalletAuthURI } from "./helpers/auth-uri.js";
+import { WalletBaseError } from "./helpers/error.js";
+import { getWalletRequest, isValidWalletRequest, isWalletRequestExpired, unlockWalletRequest, WALLET_REQUEST_KIND, } from "./helpers/request.js";
+import { getConnectionMethods, } from "./interop.js";
 /** NIP-47 Wallet Service implementation */
 export class WalletService {
     /** A fallback method to use for subscriptionMethod if none is passed in when creating the client */
@@ -48,23 +49,21 @@ export class WalletService {
         this.handlers = options.handlers;
         // Set the client's secret and public key
         if (options.secret) {
+            // Service was created with a custom secret
             this.secret = options.secret;
             this.client = getPublicKey(this.secret);
         }
+        else if (options.client) {
+            // Service was restored with only the clients pubkey
+            this.client = options.client;
+        }
         else {
+            // Generate secret and client pubkey
             this.secret = generateSecretKey();
             this.client = getPublicKey(this.secret);
         }
         // Get the subscription and publish methods
-        const subscriptionMethod = options.subscriptionMethod ||
-            options.pool?.subscription ||
-            WalletService.subscriptionMethod ||
-            WalletService.pool?.subscription;
-        if (!subscriptionMethod)
-            throw new Error("Missing subscriptionMethod, either pass a method or set WalletService.subscriptionMethod");
-        const publishMethod = options.publishMethod || options.pool?.publish || WalletService.publishMethod || WalletService.pool?.publish;
-        if (!publishMethod)
-            throw new Error("Missing publishMethod, either pass a method or set WalletService.publishMethod");
+        const { subscriptionMethod, publishMethod } = getConnectionMethods(options, WalletService);
         // Use arrow functions so "this" isn't bound to the signer
         this.subscriptionMethod = (relays, filters) => subscriptionMethod(relays, filters);
         this.publishMethod = (relays, event) => publishMethod(relays, event);
@@ -91,17 +90,23 @@ export class WalletService {
         // Get our public key
         this.pubkey = await this.signer.getPublicKey();
         // Create shared request observable with ref counting and timer
-        this.events$ = this.subscriptionMethod(this.relays, [
+        this.events$ = from(this.subscriptionMethod(this.relays, [
             {
                 kinds: [WALLET_REQUEST_KIND],
                 "#p": [this.pubkey], // Only requests directed to us
                 authors: [this.client], // Only requests from the client
             },
-        ]).pipe(
+        ])).pipe(
+        // Keep the connection open indefinitely
+        repeat(), 
+        // Retry on connection failure
+        retry(), 
         // Ignore strings (support for applesauce-relay)
         filter((event) => typeof event !== "string"), 
         // Only include valid wallet request events
-        filter((event) => event.kind === WALLET_REQUEST_KIND && event.pubkey === this.client), 
+        filter(isValidWalletRequest), 
+        // Ensure they are to our pubkey
+        filter((event) => event.pubkey === this.client), 
         // Verify event signature
         filter((event) => verifyEvent(event)), 
         // Only create a single subscription to the relays
@@ -132,6 +137,8 @@ export class WalletService {
     }
     /** Get the connection URI for the service */
     getConnectURI() {
+        if (!this.secret)
+            throw new Error("Service was not created with a secret");
         if (!this.pubkey)
             throw new Error("Service is not running");
         if (!this.relays.length)
@@ -171,13 +178,7 @@ export class WalletService {
             if (isWalletRequestExpired(requestEvent))
                 return await this.sendErrorResponse(requestEvent, "OTHER", "Request has expired");
             // Unlock the request if needed
-            let request;
-            if (isWalletRequestLocked(requestEvent)) {
-                request = await unlockWalletRequest(requestEvent, this.signer);
-            }
-            else {
-                request = getWalletRequest(requestEvent);
-            }
+            const request = await unlockWalletRequest(requestEvent, this.signer);
             if (!request)
                 return await this.sendErrorResponse(requestEvent, "OTHER", "Failed to decrypt or parse request");
             // Handle the request based on its method

package/package.json

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

package/dist/types.d.ts

@@ -1,11 +0,0 @@
-import { Filter, NostrEvent } from "nostr-tools";
-import { Observable } from "rxjs";
-/** A method used to subscribe to events on a set of relays */
-export type NostrSubscriptionMethod = (relays: string[], filters: Filter[]) => Observable<NostrEvent | string>;
-/** A method used for publishing an event, can return a Promise that completes when published or an Observable that completes when published*/
-export type NostrPublishMethod = (relays: string[], event: NostrEvent) => Promise<any> | Observable<any>;
-/** A simple pool type that combines the subscription and publish methods */
-export type NostrPool = {
-    subscription: NostrSubscriptionMethod;
-    publish: NostrPublishMethod;
-};

package/dist/types.js

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