@unicitylabs/nostr-js-sdk 0.2.5 → 0.3.1

package/dist/browser/index.umd.js

@@ -5591,6 +5591,8 @@
     const GIFT_WRAP = 1059;
     /** NIP-65: Relay list metadata */
     const RELAY_LIST = 10002;
+    /** NIP-42: Client authentication to relay */
+    const AUTH = 22242;
     /** NIP-78: Application-specific data (parameterized replaceable) */
     const APP_DATA = 30078;
     // ============================================================================
@@ -5606,6 +5608,8 @@
     const FILE_METADATA = 31114;
     /** Unicity: Payment request */
     const PAYMENT_REQUEST = 31115;
+    /** Unicity: Payment request response (accept/decline) */
+    const PAYMENT_REQUEST_RESPONSE = 31116;
     // ============================================================================
     // Event Kind Classification Functions
     // ============================================================================
@@ -5681,6 +5685,8 @@
                 return 'File Metadata';
             case PAYMENT_REQUEST:
                 return 'Payment Request';
+            case PAYMENT_REQUEST_RESPONSE:
+                return 'Payment Request Response';
             default:
                 if (isReplaceable(kind)) {
                     return `Replaceable (${kind})`;
@@ -5700,6 +5706,7 @@
         AGENT_LOCATION: AGENT_LOCATION,
         AGENT_PROFILE: AGENT_PROFILE,
         APP_DATA: APP_DATA,
+        AUTH: AUTH,
         CHAT_MESSAGE: CHAT_MESSAGE,
         CONTACTS: CONTACTS,
         DELETION: DELETION,
@@ -5707,6 +5714,7 @@
         FILE_METADATA: FILE_METADATA,
         GIFT_WRAP: GIFT_WRAP,
         PAYMENT_REQUEST: PAYMENT_REQUEST,
+        PAYMENT_REQUEST_RESPONSE: PAYMENT_REQUEST_RESPONSE,
         PROFILE: PROFILE,
         REACTION: REACTION,
         READ_RECEIPT: READ_RECEIPT,
@@ -5999,6 +6007,13 @@
     const DEFAULT_RECONNECT_INTERVAL_MS = 1000;
     const DEFAULT_MAX_RECONNECT_INTERVAL_MS = 30000;
     const DEFAULT_PING_INTERVAL_MS = 30000;
+    /**
+     * Delay before resubscribing after NIP-42 authentication.
+     * This gives the relay time to process the AUTH response before we send
+     * subscription requests. Without this delay, some relays may still reject
+     * the subscriptions as the AUTH hasn't been fully processed yet.
+     */
+    const AUTH_RESUBSCRIBE_DELAY_MS = 100;
     /**
      * NostrClient provides the main interface for Nostr protocol operations.
      */
@@ -6343,6 +6358,9 @@
                     case 'CLOSED':
                         this.handleClosedMessage(json);
                         break;
+                    case 'AUTH':
+                        this.handleAuthMessage(_url, json);
+                        break;
                 }
             }
             catch {
@@ -6423,6 +6441,33 @@
                 subscription.listener.onError(subscriptionId, `Subscription closed: ${message}`);
             }
         }
+        /**
+         * Handle AUTH message from relay (NIP-42 authentication challenge).
+         */
+        handleAuthMessage(relayUrl, json) {
+            if (json.length < 2)
+                return;
+            const challenge = json[1];
+            const relay = this.relays.get(relayUrl);
+            if (!relay?.socket || !relay.connected)
+                return;
+            // Create and sign the auth event (kind 22242)
+            const authEvent = Event.create(this.keyManager, {
+                kind: AUTH,
+                tags: [
+                    ['relay', relayUrl],
+                    ['challenge', challenge],
+                ],
+                content: '',
+            });
+            // Send AUTH response
+            const message = JSON.stringify(['AUTH', authEvent.toJSON()]);
+            relay.socket.send(message);
+            // Re-send subscriptions after auth (relay may have ignored pre-auth requests)
+            setTimeout(() => {
+                this.resubscribeAll(relayUrl);
+            }, AUTH_RESUBSCRIBE_DELAY_MS);
+        }
         /**
          * Disconnect from all relays.
          */
@@ -6569,6 +6614,41 @@
             const event = await PaymentRequestProtocol$1.createPaymentRequestEvent(this.keyManager, targetPubkeyHex, request);
             return this.publishEvent(event);
         }
+        /**
+         * Send a payment request response (decline/expiration notification).
+         * @param targetPubkeyHex Original requester's public key
+         * @param response Response details
+         * @returns Promise that resolves with the event ID
+         */
+        async sendPaymentRequestResponse(targetPubkeyHex, response) {
+            const PaymentRequestProtocol$1 = await Promise.resolve().then(function () { return PaymentRequestProtocol; });
+            const event = await PaymentRequestProtocol$1.createPaymentRequestResponseEvent(this.keyManager, targetPubkeyHex, {
+                requestId: response.requestId,
+                originalEventId: response.originalEventId,
+                status: response.status === 'DECLINED'
+                    ? PaymentRequestProtocol$1.ResponseStatus.DECLINED
+                    : PaymentRequestProtocol$1.ResponseStatus.EXPIRED,
+                reason: response.reason,
+            });
+            return this.publishEvent(event);
+        }
+        /**
+         * Send a payment request decline response.
+         * Convenience method for declining a payment request.
+         * @param originalRequestSenderPubkey Pubkey of who sent the original payment request
+         * @param originalEventId Event ID of the original payment request
+         * @param requestId Request ID from the original payment request
+         * @param reason Optional reason for declining
+         * @returns Promise that resolves with the event ID
+         */
+        async sendPaymentRequestDecline(originalRequestSenderPubkey, originalEventId, requestId, reason) {
+            return this.sendPaymentRequestResponse(originalRequestSenderPubkey, {
+                requestId,
+                originalEventId,
+                status: 'DECLINED',
+                reason,
+            });
+        }
         /**
          * Publish a nametag binding.
          * @param nametagId Nametag identifier
@@ -10204,6 +10284,20 @@
      */
     /** Prefix for payment request messages */
     const MESSAGE_PREFIX = 'payment_request:';
+    /** Prefix for payment request response messages */
+    const RESPONSE_PREFIX = 'payment_request_response:';
+    /** Default deadline duration: 5 minutes in milliseconds */
+    const DEFAULT_DEADLINE_MS = 5 * 60 * 1000;
+    /**
+     * Payment request response status.
+     */
+    var ResponseStatus;
+    (function (ResponseStatus) {
+        /** Payment request was declined by the recipient */
+        ResponseStatus["DECLINED"] = "DECLINED";
+        /** Payment request expired (deadline passed) */
+        ResponseStatus["EXPIRED"] = "EXPIRED";
+    })(ResponseStatus || (ResponseStatus = {}));
     /**
      * Generate a short unique request ID.
      */
@@ -10244,6 +10338,13 @@
     async function createPaymentRequestEvent(keyManager, targetPubkeyHex, request) {
         // Generate request ID if not provided
         const requestId = request.requestId || generateRequestId();
+        // Calculate deadline: use provided value, or default to 5 minutes from now
+        // If explicitly set to null, no deadline
+        const deadline = request.deadline === null
+            ? null
+            : request.deadline !== undefined
+                ? request.deadline
+                : Date.now() + DEFAULT_DEADLINE_MS;
         // Serialize request to JSON
         const requestJson = JSON.stringify({
             amount: String(request.amount), // Convert to string for JSON compatibility with bigint
@@ -10251,6 +10352,7 @@
             message: request.message,
             recipientNametag: request.recipientNametag,
             requestId: requestId,
+            deadline: deadline,
         });
         // Add prefix and encrypt
         const message = MESSAGE_PREFIX + requestJson;
@@ -10322,6 +10424,7 @@
             senderPubkey: event.pubkey,
             timestamp: event.created_at * 1000, // Convert to milliseconds
             eventId: event.id,
+            deadline: parsed.deadline !== undefined ? parsed.deadline : null,
         };
     }
     /**
@@ -10419,18 +10522,166 @@
         const fractionalPart = BigInt(fractionalStr);
         return wholePart * multiplier + fractionalPart;
     }
+    // ============================================================================
+    // Payment Request Response Functions
+    // ============================================================================
+    /**
+     * Check if a parsed payment request has expired.
+     * @param request Parsed payment request
+     * @returns true if the request has a deadline and it has passed
+     */
+    function isExpired(request) {
+        return request.deadline !== null && Date.now() > request.deadline;
+    }
+    /**
+     * Get remaining time until deadline in milliseconds.
+     * @param request Parsed payment request
+     * @returns Remaining time in ms, 0 if expired, null if no deadline
+     */
+    function getRemainingTimeMs(request) {
+        if (request.deadline === null)
+            return null;
+        const remaining = request.deadline - Date.now();
+        return remaining > 0 ? remaining : 0;
+    }
+    /**
+     * Create a payment request response event (for decline/expiration).
+     *
+     * Event structure:
+     * - Kind: 31116 (PAYMENT_REQUEST_RESPONSE)
+     * - Tags:
+     *   - ["p", "<target_pubkey_hex>"] - Original requester
+     *   - ["type", "payment_request_response"]
+     *   - ["status", "DECLINED" | "EXPIRED"]
+     *   - ["e", "<original_event_id>", "", "reply"] - Reference to original request
+     * - Content: NIP-04 encrypted response JSON
+     *
+     * @param keyManager Key manager with signing keys
+     * @param targetPubkeyHex Original requester's public key
+     * @param response Response details
+     * @returns Signed event
+     */
+    async function createPaymentRequestResponseEvent(keyManager, targetPubkeyHex, response) {
+        // Serialize response to JSON
+        const responseJson = JSON.stringify({
+            requestId: response.requestId,
+            originalEventId: response.originalEventId,
+            status: response.status,
+            reason: response.reason,
+        });
+        // Add prefix and encrypt
+        const message = RESPONSE_PREFIX + responseJson;
+        const encryptedContent = await keyManager.encryptHex(message, targetPubkeyHex);
+        // Build tags
+        const tags = [
+            ['p', targetPubkeyHex],
+            ['type', 'payment_request_response'],
+            ['status', response.status],
+        ];
+        // Add reference to original event
+        if (response.originalEventId) {
+            tags.push(['e', response.originalEventId, '', 'reply']);
+        }
+        const event = Event.create(keyManager, {
+            kind: PAYMENT_REQUEST_RESPONSE,
+            tags,
+            content: encryptedContent,
+        });
+        return event;
+    }
+    /**
+     * Parse a payment request response event.
+     * Decrypts and parses the response data.
+     *
+     * @param event Payment request response event
+     * @param keyManager Key manager for decryption
+     * @returns Parsed payment request response
+     * @throws Error if the event is not a valid payment request response
+     */
+    async function parsePaymentRequestResponse(event, keyManager) {
+        // Verify event kind
+        if (event.kind !== PAYMENT_REQUEST_RESPONSE) {
+            throw new Error('Event is not a payment request response');
+        }
+        // Determine the peer's public key for decryption
+        let peerPubkeyHex;
+        if (keyManager.isMyPublicKey(event.pubkey)) {
+            // We sent this response, decrypt with target's key
+            const targetPubkey = event.getTagValue('p');
+            if (!targetPubkey) {
+                throw new Error('No target found in event');
+            }
+            peerPubkeyHex = targetPubkey;
+        }
+        else {
+            // We received this response, decrypt with sender's key
+            peerPubkeyHex = event.pubkey;
+        }
+        // Decrypt the content
+        const decrypted = await keyManager.decryptHex(event.content, peerPubkeyHex);
+        // Validate prefix
+        if (!decrypted.startsWith(RESPONSE_PREFIX)) {
+            throw new Error('Invalid payment request response format: missing prefix');
+        }
+        // Parse JSON
+        const responseJson = decrypted.slice(RESPONSE_PREFIX.length);
+        const parsed = JSON.parse(responseJson);
+        return {
+            requestId: parsed.requestId,
+            originalEventId: parsed.originalEventId,
+            status: parsed.status,
+            reason: parsed.reason,
+            senderPubkey: event.pubkey,
+            eventId: event.id,
+            timestamp: event.created_at * 1000,
+        };
+    }
+    /**
+     * Check if an event is a payment request response.
+     * @param event Event to check
+     * @returns true if the event is a payment request response
+     */
+    function isPaymentRequestResponse(event) {
+        return (event.kind === PAYMENT_REQUEST_RESPONSE &&
+            event.getTagValue('type') === 'payment_request_response');
+    }
+    /**
+     * Get the response status from a payment request response event (from unencrypted tag).
+     * @param event Payment request response event
+     * @returns Status string, or undefined if not found
+     */
+    function getResponseStatus(event) {
+        return event.getTagValue('status');
+    }
+    /**
+     * Get the referenced original event ID from the response event.
+     * @param event Payment request response event
+     * @returns Original event ID, or undefined if not found
+     */
+    function getOriginalEventId(event) {
+        return event.getTagValue('e');
+    }
 
     var PaymentRequestProtocol = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        DEFAULT_DEADLINE_MS: DEFAULT_DEADLINE_MS,
+        get ResponseStatus () { return ResponseStatus; },
         createPaymentRequestEvent: createPaymentRequestEvent,
+        createPaymentRequestResponseEvent: createPaymentRequestResponseEvent,
         formatAmount: formatAmount,
         getAmount: getAmount,
+        getOriginalEventId: getOriginalEventId,
         getRecipientNametag: getRecipientNametag,
+        getRemainingTimeMs: getRemainingTimeMs,
+        getResponseStatus: getResponseStatus,
         getSender: getSender,
         getTarget: getTarget,
+        isExpired: isExpired,
         isPaymentRequest: isPaymentRequest,
+        isPaymentRequestResponse: isPaymentRequestResponse,
         parseAmount: parseAmount,
-        parsePaymentRequest: parsePaymentRequest
+        parsePaymentRequest: parsePaymentRequest,
+        parsePaymentRequestResponse: parsePaymentRequestResponse
     });
 
     /**
@@ -10452,6 +10703,7 @@
     exports.AGENT_LOCATION = AGENT_LOCATION;
     exports.AGENT_PROFILE = AGENT_PROFILE;
     exports.APP_DATA = APP_DATA;
+    exports.AUTH = AUTH;
     exports.Bech32 = bech32;
     exports.CHAT_MESSAGE = CHAT_MESSAGE;
     exports.CLOSED = CLOSED;
@@ -10476,6 +10728,7 @@
     exports.NostrKeyManager = NostrKeyManager;
     exports.OPEN = OPEN;
     exports.PAYMENT_REQUEST = PAYMENT_REQUEST;
+    exports.PAYMENT_REQUEST_RESPONSE = PAYMENT_REQUEST_RESPONSE;
     exports.PROFILE = PROFILE;
     exports.PaymentRequestProtocol = PaymentRequestProtocol;
     exports.REACTION = REACTION;