@unicitylabs/nostr-js-sdk 0.2.4 → 0.3.0

package/dist/browser/index.umd.js

@@ -5606,6 +5606,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 +5683,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})`;
@@ -5707,6 +5711,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,
@@ -6260,14 +6265,16 @@
                     return;
                 }
                 // Send a subscription request as a ping (relays respond with EOSE)
-                // Using a unique subscription ID that we immediately close
+                // Use a single fixed subscription ID per relay to avoid accumulating subscriptions
+                // Note: limit:1 is used because some relays don't respond to limit:0
                 try {
-                    const pingSubId = `ping-${Date.now()}`;
-                    const pingMessage = JSON.stringify(['REQ', pingSubId, { limit: 0 }]);
-                    relay.socket.send(pingMessage);
-                    // Immediately close the subscription
+                    const pingSubId = `ping`;
+                    // First close any existing ping subscription to ensure we don't accumulate
                     const closeMessage = JSON.stringify(['CLOSE', pingSubId]);
                     relay.socket.send(closeMessage);
+                    // Then send the new ping request (limit:1 ensures relay sends EOSE)
+                    const pingMessage = JSON.stringify(['REQ', pingSubId, { limit: 1 }]);
+                    relay.socket.send(pingMessage);
                 }
                 catch {
                     // Send failed, connection likely dead
@@ -6567,6 +6574,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
@@ -10202,6 +10244,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.
      */
@@ -10242,6 +10298,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
@@ -10249,6 +10312,7 @@
             message: request.message,
             recipientNametag: request.recipientNametag,
             requestId: requestId,
+            deadline: deadline,
         });
         // Add prefix and encrypt
         const message = MESSAGE_PREFIX + requestJson;
@@ -10320,6 +10384,7 @@
             senderPubkey: event.pubkey,
             timestamp: event.created_at * 1000, // Convert to milliseconds
             eventId: event.id,
+            deadline: parsed.deadline !== undefined ? parsed.deadline : null,
         };
     }
     /**
@@ -10417,18 +10482,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
     });
 
     /**
@@ -10474,6 +10687,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;