applesauce-wallet-connect 3.1.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,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";
+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 */
+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,127 +1,23 @@
-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";
+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;
-/** 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;
+/** Type for events with unlocked hidden content */
+export type UnlockedWalletRequest<Method extends TWalletMethod = TWalletMethod> = UnlockedHiddenContent & {
+    [WalletRequestSymbol]: Method["request"];
+};
 /** Checks if a kind 23194 event is locked */
-export declare function isWalletRequestLocked(request: NostrEvent): boolean;
+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 | null>;
+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 | null;
+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;
 /** Returns the expiration timestamp from a request */
 export declare function getWalletRequestExpiration(request: NostrEvent): number | undefined;
@@ -129,3 +25,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;
+}