@bsv/message-box-client 1.1.9 → 1.1.11

package/dist/cjs/src/MessageBoxClient.js

@@ -22,11 +22,44 @@
  * @author Project Babbage
  * @license Open BSV License
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageBoxClient = void 0;
 const sdk_1 = require("@bsv/sdk");
 const authsocket_client_1 = require("@bsv/authsocket-client");
-const logger_js_1 = require("./Utils/logger.js");
+const Logger = __importStar(require("./Utils/logger.js"));
 const DEFAULT_MAINNET_HOST = 'https://messagebox.babbage.systems';
 const DEFAULT_TESTNET_HOST = 'https://staging-messagebox.babbage.systems';
 /**
@@ -61,7 +94,7 @@ class MessageBoxClient {
      * @constructor
      * @param {Object} options - Initialization options for the MessageBoxClient.
      * @param {string} [options.host] - The base URL of the MessageBox server. If omitted, defaults to mainnet/testnet hosts.
-     * @param {WalletClient} options.walletClient - Wallet instance used for authentication, signing, and encryption.
+     * @param {WalletInterface} options.walletClient - Wallet instance used for authentication, signing, and encryption.
      * @param {boolean} [options.enableLogging=false] - Whether to enable detailed debug logging to the console.
      * @param {'local' | 'mainnet' | 'testnet'} [options.networkPreset='mainnet'] - Overlay network preset used for routing and advertisement lookup.
      *
@@ -97,7 +130,7 @@ class MessageBoxClient {
             networkPreset
         });
         if (enableLogging) {
-            logger_js_1.Logger.enable();
+            Logger.enable();
         }
     }
     /**
@@ -141,7 +174,7 @@ class MessageBoxClient {
         const [firstAdvertisement] = await this.queryAdvertisements(identityKey, normalizedHost);
         // 3. If none our found, anoint this host
         if (firstAdvertisement == null || ((_a = firstAdvertisement === null || firstAdvertisement === void 0 ? void 0 : firstAdvertisement.host) === null || _a === void 0 ? void 0 : _a.trim()) === '' || (firstAdvertisement === null || firstAdvertisement === void 0 ? void 0 : firstAdvertisement.host) !== normalizedHost) {
-            logger_js_1.Logger.log('[MB CLIENT] Anointing host:', normalizedHost);
+            Logger.log('[MB CLIENT] Anointing host:', normalizedHost);
             const { txid } = await this.anointHost(normalizedHost);
             if (txid == null || txid.trim() === '') {
                 throw new Error('Failed to anoint host: No transaction ID returned');
@@ -186,15 +219,15 @@ class MessageBoxClient {
         if (this.myIdentityKey != null && this.myIdentityKey.trim() !== '') {
             return this.myIdentityKey;
         }
-        logger_js_1.Logger.log('[MB CLIENT] Fetching identity key...');
+        Logger.log('[MB CLIENT] Fetching identity key...');
         try {
             const keyResult = await this.walletClient.getPublicKey({ identityKey: true });
             this.myIdentityKey = keyResult.publicKey;
-            logger_js_1.Logger.log(`[MB CLIENT] Identity key fetched: ${this.myIdentityKey}`);
+            Logger.log(`[MB CLIENT] Identity key fetched: ${this.myIdentityKey}`);
             return this.myIdentityKey;
         }
         catch (error) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
+            Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
             throw new Error('Identity key retrieval failed');
         }
     }
@@ -237,24 +270,24 @@ class MessageBoxClient {
      */
     async initializeConnection() {
         await this.assertInitialized();
-        logger_js_1.Logger.log('[MB CLIENT] initializeConnection() STARTED');
+        Logger.log('[MB CLIENT] initializeConnection() STARTED');
         if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
-            logger_js_1.Logger.log('[MB CLIENT] Fetching identity key...');
+            Logger.log('[MB CLIENT] Fetching identity key...');
             try {
                 const keyResult = await this.walletClient.getPublicKey({ identityKey: true });
                 this.myIdentityKey = keyResult.publicKey;
-                logger_js_1.Logger.log(`[MB CLIENT] Identity key fetched successfully: ${this.myIdentityKey}`);
+                Logger.log(`[MB CLIENT] Identity key fetched successfully: ${this.myIdentityKey}`);
             }
             catch (error) {
-                logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
+                Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
                 throw new Error('Identity key retrieval failed');
             }
         }
         if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] Identity key is still missing after retrieval!');
+            Logger.error('[MB CLIENT ERROR] Identity key is still missing after retrieval!');
             throw new Error('Identity key is missing');
         }
-        logger_js_1.Logger.log('[MB CLIENT] Setting up WebSocket connection...');
+        Logger.log('[MB CLIENT] Setting up WebSocket connection...');
         if (this.socket == null) {
             if (typeof this.host !== 'string' || this.host.trim() === '') {
                 throw new Error('Cannot initialize WebSocket: Host is not set');
@@ -264,11 +297,11 @@ class MessageBoxClient {
             let authenticated = false;
             this.socket.on('connect', () => {
                 var _a;
-                logger_js_1.Logger.log('[MB CLIENT] Connected to WebSocket.');
+                Logger.log('[MB CLIENT] Connected to WebSocket.');
                 if (!identitySent) {
-                    logger_js_1.Logger.log('[MB CLIENT] Sending authentication data:', this.myIdentityKey);
+                    Logger.log('[MB CLIENT] Sending authentication data:', this.myIdentityKey);
                     if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
-                        logger_js_1.Logger.error('[MB CLIENT ERROR] Cannot send authentication: Identity key is missing!');
+                        Logger.error('[MB CLIENT ERROR] Cannot send authentication: Identity key is missing!');
                     }
                     else {
                         (_a = this.socket) === null || _a === void 0 ? void 0 : _a.emit('authenticated', { identityKey: this.myIdentityKey });
@@ -278,28 +311,28 @@ class MessageBoxClient {
             });
             // Listen for authentication success from the server
             this.socket.on('authenticationSuccess', (data) => {
-                logger_js_1.Logger.log(`[MB CLIENT] WebSocket authentication successful: ${JSON.stringify(data)}`);
+                Logger.log(`[MB CLIENT] WebSocket authentication successful: ${JSON.stringify(data)}`);
                 authenticated = true;
             });
             // Handle authentication failures
             this.socket.on('authenticationFailed', (data) => {
-                logger_js_1.Logger.error(`[MB CLIENT ERROR] WebSocket authentication failed: ${JSON.stringify(data)}`);
+                Logger.error(`[MB CLIENT ERROR] WebSocket authentication failed: ${JSON.stringify(data)}`);
                 authenticated = false;
             });
             this.socket.on('disconnect', () => {
-                logger_js_1.Logger.log('[MB CLIENT] Disconnected from MessageBox server');
+                Logger.log('[MB CLIENT] Disconnected from MessageBox server');
                 this.socket = undefined;
                 identitySent = false;
                 authenticated = false;
             });
             this.socket.on('error', (error) => {
-                logger_js_1.Logger.error('[MB CLIENT ERROR] WebSocket error:', error);
+                Logger.error('[MB CLIENT ERROR] WebSocket error:', error);
             });
             // Wait for authentication confirmation before proceeding
             await new Promise((resolve, reject) => {
                 setTimeout(() => {
                     if (authenticated) {
-                        logger_js_1.Logger.log('[MB CLIENT] WebSocket fully authenticated and ready!');
+                        Logger.log('[MB CLIENT] WebSocket fully authenticated and ready!');
                         resolve();
                     }
                     else {
@@ -330,7 +363,7 @@ class MessageBoxClient {
     async resolveHostForRecipient(identityKey) {
         const advertisementTokens = await this.queryAdvertisements(identityKey);
         if (advertisementTokens.length === 0) {
-            logger_js_1.Logger.warn(`[MB CLIENT] No advertisements for ${identityKey}, using default host ${this.host}`);
+            Logger.warn(`[MB CLIENT] No advertisements for ${identityKey}, using default host ${this.host}`);
             return this.host;
         }
         // Return the first host found
@@ -355,7 +388,7 @@ class MessageBoxClient {
                 query
             });
             if (result.type !== 'output-list') {
-                throw new Error(`Unexpected result type: ${result.type}`);
+                throw new Error(`Unexpected result type: ${String(result.type)}`);
             }
             for (const output of result.outputs) {
                 try {
@@ -380,7 +413,7 @@ class MessageBoxClient {
             }
         }
         catch (err) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] _queryAdvertisements failed:', err);
+            Logger.error('[MB CLIENT ERROR] _queryAdvertisements failed:', err);
         }
         return hosts;
     }
@@ -406,10 +439,10 @@ class MessageBoxClient {
     async joinRoom(messageBox) {
         var _a, _b;
         await this.assertInitialized();
-        logger_js_1.Logger.log(`[MB CLIENT] Attempting to join WebSocket room: ${messageBox}`);
+        Logger.log(`[MB CLIENT] Attempting to join WebSocket room: ${messageBox}`);
         // Ensure WebSocket connection is established first
         if (this.socket == null) {
-            logger_js_1.Logger.log('[MB CLIENT] No WebSocket connection. Initializing...');
+            Logger.log('[MB CLIENT] No WebSocket connection. Initializing...');
             await this.initializeConnection();
         }
         if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
@@ -417,17 +450,17 @@ class MessageBoxClient {
         }
         const roomId = `${(_a = this.myIdentityKey) !== null && _a !== void 0 ? _a : ''}-${messageBox}`;
         if (this.joinedRooms.has(roomId)) {
-            logger_js_1.Logger.log(`[MB CLIENT] Already joined WebSocket room: ${roomId}`);
+            Logger.log(`[MB CLIENT] Already joined WebSocket room: ${roomId}`);
             return;
         }
         try {
-            logger_js_1.Logger.log(`[MB CLIENT] Joining WebSocket room: ${roomId}`);
+            Logger.log(`[MB CLIENT] Joining WebSocket room: ${roomId}`);
             await ((_b = this.socket) === null || _b === void 0 ? void 0 : _b.emit('joinRoom', roomId));
             this.joinedRooms.add(roomId);
-            logger_js_1.Logger.log(`[MB CLIENT] Successfully joined room: ${roomId}`);
+            Logger.log(`[MB CLIENT] Successfully joined room: ${roomId}`);
         }
         catch (error) {
-            logger_js_1.Logger.error(`[MB CLIENT ERROR] Failed to join WebSocket room: ${roomId}`, error);
+            Logger.error(`[MB CLIENT ERROR] Failed to join WebSocket room: ${roomId}`, error);
         }
     }
     /**
@@ -461,7 +494,7 @@ class MessageBoxClient {
     async listenForLiveMessages({ onMessage, messageBox }) {
         var _a;
         await this.assertInitialized();
-        logger_js_1.Logger.log(`[MB CLIENT] Setting up listener for WebSocket room: ${messageBox}`);
+        Logger.log(`[MB CLIENT] Setting up listener for WebSocket room: ${messageBox}`);
         // Ensure WebSocket connection and room join
         await this.joinRoom(messageBox);
         // Ensure identity key is available before creating roomId
@@ -469,10 +502,10 @@ class MessageBoxClient {
             throw new Error('[MB CLIENT ERROR] Identity key is missing. Cannot construct room ID.');
         }
         const roomId = `${this.myIdentityKey}-${messageBox}`;
-        logger_js_1.Logger.log(`[MB CLIENT] Listening for messages in room: ${roomId}`);
+        Logger.log(`[MB CLIENT] Listening for messages in room: ${roomId}`);
         (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(`sendMessage-${roomId}`, (message) => {
             void (async () => {
-                logger_js_1.Logger.log(`[MB CLIENT] Received message in room ${roomId}:`, message);
+                Logger.log(`[MB CLIENT] Received message in room ${roomId}:`, message);
                 try {
                     let parsedBody = message.body;
                     if (typeof parsedBody === 'string') {
@@ -486,7 +519,7 @@ class MessageBoxClient {
                     if (parsedBody != null &&
                         typeof parsedBody === 'object' &&
                         typeof parsedBody.encryptedMessage === 'string') {
-                        logger_js_1.Logger.log(`[MB CLIENT] Decrypting message from ${String(message.sender)}...`);
+                        Logger.log(`[MB CLIENT] Decrypting message from ${String(message.sender)}...`);
                         const decrypted = await this.walletClient.decrypt({
                             protocolID: [1, 'messagebox'],
                             keyID: '1',
@@ -496,7 +529,7 @@ class MessageBoxClient {
                         message.body = sdk_1.Utils.toUTF8(decrypted.plaintext);
                     }
                     else {
-                        logger_js_1.Logger.log('[MB CLIENT] Message is not encrypted.');
+                        Logger.log('[MB CLIENT] Message is not encrypted.');
                         message.body = typeof parsedBody === 'string'
                             ? parsedBody
                             : (() => { try {
@@ -508,7 +541,7 @@ class MessageBoxClient {
                     }
                 }
                 catch (err) {
-                    logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to parse or decrypt live message:', err);
+                    Logger.error('[MB CLIENT ERROR] Failed to parse or decrypt live message:', err);
                     message.body = '[Error: Failed to decrypt or parse message]';
                 }
                 onMessage(message);
@@ -544,7 +577,7 @@ class MessageBoxClient {
      *   body: { amount: 1000 }
      * })
      */
-    async sendLiveMessage({ recipient, messageBox, body, messageId, skipEncryption }) {
+    async sendLiveMessage({ recipient, messageBox, body, messageId, skipEncryption, checkPermissions }) {
         await this.assertInitialized();
         if (recipient == null || recipient.trim() === '') {
             throw new Error('[MB CLIENT ERROR] Recipient identity key is required');
@@ -559,7 +592,7 @@ class MessageBoxClient {
         await this.joinRoom(messageBox);
         // Fallback to HTTP if WebSocket is not connected
         if (this.socket == null || !this.socket.connected) {
-            logger_js_1.Logger.warn('[MB CLIENT WARNING] WebSocket not connected, falling back to HTTP');
+            Logger.warn('[MB CLIENT WARNING] WebSocket not connected, falling back to HTTP');
             const targetHost = await this.resolveHostForRecipient(recipient);
             return await this.sendMessage({ recipient, messageBox, body }, targetHost);
         }
@@ -574,11 +607,11 @@ class MessageBoxClient {
             finalMessageId = messageId !== null && messageId !== void 0 ? messageId : Array.from(hmac.hmac).map(b => b.toString(16).padStart(2, '0')).join('');
         }
         catch (error) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to generate HMAC:', error);
+            Logger.error('[MB CLIENT ERROR] Failed to generate HMAC:', error);
             throw new Error('Failed to generate message identifier.');
         }
         const roomId = `${recipient}-${messageBox}`;
-        logger_js_1.Logger.log(`[MB CLIENT] Sending WebSocket message to room: ${roomId}`);
+        Logger.log(`[MB CLIENT] Sending WebSocket message to room: ${roomId}`);
         let outgoingBody;
         if (skipEncryption === true) {
             outgoingBody = typeof body === 'string' ? body : JSON.stringify(body);
@@ -606,15 +639,16 @@ class MessageBoxClient {
                 if (typeof (socketAny === null || socketAny === void 0 ? void 0 : socketAny.off) === 'function') {
                     socketAny.off(ackEvent, ackHandler);
                 }
-                logger_js_1.Logger.log('[MB CLIENT] Received WebSocket acknowledgment:', response);
+                Logger.log('[MB CLIENT] Received WebSocket acknowledgment:', response);
                 if (response == null || response.status !== 'success') {
-                    logger_js_1.Logger.warn('[MB CLIENT] WebSocket message failed or returned unexpected response. Falling back to HTTP.');
+                    Logger.warn('[MB CLIENT] WebSocket message failed or returned unexpected response. Falling back to HTTP.');
                     const fallbackMessage = {
                         recipient,
                         messageBox,
                         body,
                         messageId: finalMessageId,
-                        skipEncryption
+                        skipEncryption,
+                        checkPermissions
                     };
                     this.resolveHostForRecipient(recipient)
                         .then(async (host) => {
@@ -624,7 +658,7 @@ class MessageBoxClient {
                         .catch(reject);
                 }
                 else {
-                    logger_js_1.Logger.log('[MB CLIENT] Message sent successfully via WebSocket:', response);
+                    Logger.log('[MB CLIENT] Message sent successfully via WebSocket:', response);
                     resolve(response);
                 }
             };
@@ -647,13 +681,14 @@ class MessageBoxClient {
                     if (typeof (socketAny === null || socketAny === void 0 ? void 0 : socketAny.off) === 'function') {
                         socketAny.off(ackEvent, ackHandler);
                     }
-                    logger_js_1.Logger.warn('[CLIENT] WebSocket acknowledgment timed out, falling back to HTTP');
+                    Logger.warn('[CLIENT] WebSocket acknowledgment timed out, falling back to HTTP');
                     const fallbackMessage = {
                         recipient,
                         messageBox,
                         body,
                         messageId: finalMessageId,
-                        skipEncryption
+                        skipEncryption,
+                        checkPermissions
                     };
                     this.resolveHostForRecipient(recipient)
                         .then(async (host) => {
@@ -683,14 +718,14 @@ class MessageBoxClient {
     async leaveRoom(messageBox) {
         await this.assertInitialized();
         if (this.socket == null) {
-            logger_js_1.Logger.warn('[MB CLIENT] Attempted to leave a room but WebSocket is not connected.');
+            Logger.warn('[MB CLIENT] Attempted to leave a room but WebSocket is not connected.');
             return;
         }
         if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
             throw new Error('[MB CLIENT ERROR] Identity key is not defined');
         }
         const roomId = `${this.myIdentityKey}-${messageBox}`;
-        logger_js_1.Logger.log(`[MB CLIENT] Leaving WebSocket room: ${roomId}`);
+        Logger.log(`[MB CLIENT] Leaving WebSocket room: ${roomId}`);
         this.socket.emit('leaveRoom', roomId);
         // Ensure the room is removed from tracking
         this.joinedRooms.delete(roomId);
@@ -711,12 +746,12 @@ class MessageBoxClient {
     async disconnectWebSocket() {
         await this.assertInitialized();
         if (this.socket != null) {
-            logger_js_1.Logger.log('[MB CLIENT] Closing WebSocket connection...');
+            Logger.log('[MB CLIENT] Closing WebSocket connection...');
             this.socket.disconnect();
             this.socket = undefined;
         }
         else {
-            logger_js_1.Logger.log('[MB CLIENT] No active WebSocket connection to close.');
+            Logger.log('[MB CLIENT] No active WebSocket connection to close.');
         }
     }
     /**
@@ -758,6 +793,33 @@ class MessageBoxClient {
         if (message.body == null || (typeof message.body === 'string' && message.body.trim().length === 0)) {
             throw new Error('Every message must have a body!');
         }
+        // Optional permission checking for backwards compatibility
+        let paymentData;
+        if (message.checkPermissions === true) {
+            try {
+                Logger.log('[MB CLIENT] Checking permissions and fees for message...');
+                // Get quote to check if payment is required
+                const quote = await this.getMessageBoxQuote({
+                    recipient: message.recipient,
+                    messageBox: message.messageBox
+                });
+                if (quote.recipientFee === -1) {
+                    throw new Error('You have been blocked from sending messages to this recipient.');
+                }
+                if (quote.recipientFee > 0 || quote.deliveryFee > 0) {
+                    const requiredPayment = quote.recipientFee + quote.deliveryFee;
+                    if (requiredPayment > 0) {
+                        Logger.log(`[MB CLIENT] Creating payment of ${requiredPayment} sats for message...`);
+                        // Create payment using helper method
+                        paymentData = await this.createMessagePayment(message.recipient, quote, overrideHost);
+                        Logger.log('[MB CLIENT] Payment data prepared:', paymentData);
+                    }
+                }
+            }
+            catch (error) {
+                throw new Error(`Permission check failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
         let messageId;
         try {
             const hmac = await this.walletClient.createHmac({
@@ -769,7 +831,7 @@ class MessageBoxClient {
             messageId = (_a = message.messageId) !== null && _a !== void 0 ? _a : Array.from(hmac.hmac).map(b => b.toString(16).padStart(2, '0')).join('');
         }
         catch (error) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to generate HMAC:', error);
+            Logger.error('[MB CLIENT ERROR] Failed to generate HMAC:', error);
             throw new Error('Failed to generate message identifier.');
         }
         let finalBody;
@@ -790,20 +852,21 @@ class MessageBoxClient {
                 ...message,
                 messageId,
                 body: finalBody
-            }
+            },
+            ...(paymentData != null && { payment: paymentData })
         };
         try {
             const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : await this.resolveHostForRecipient(message.recipient);
-            logger_js_1.Logger.log('[MB CLIENT] Sending HTTP request to:', `${finalHost}/sendMessage`);
-            logger_js_1.Logger.log('[MB CLIENT] Request Body:', JSON.stringify(requestBody, null, 2));
+            Logger.log('[MB CLIENT] Sending HTTP request to:', `${finalHost}/sendMessage`);
+            Logger.log('[MB CLIENT] Request Body:', JSON.stringify(requestBody, null, 2));
             if (this.myIdentityKey == null || this.myIdentityKey === '') {
                 try {
                     const keyResult = await this.walletClient.getPublicKey({ identityKey: true });
                     this.myIdentityKey = keyResult.publicKey;
-                    logger_js_1.Logger.log(`[MB CLIENT] Fetched identity key before sending request: ${this.myIdentityKey}`);
+                    Logger.log(`[MB CLIENT] Fetched identity key before sending request: ${this.myIdentityKey}`);
                 }
                 catch (error) {
-                    logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
+                    Logger.error('[MB CLIENT ERROR] Failed to fetch identity key:', error);
                     throw new Error('Identity key retrieval failed');
                 }
             }
@@ -818,20 +881,20 @@ class MessageBoxClient {
                 throw new Error('[MB CLIENT ERROR] Response body has already been used!');
             }
             const parsedResponse = await response.json();
-            logger_js_1.Logger.log('[MB CLIENT] Raw Response Body:', parsedResponse);
+            Logger.log('[MB CLIENT] Raw Response Body:', parsedResponse);
             if (!response.ok) {
-                logger_js_1.Logger.error(`[MB CLIENT ERROR] Failed to send message. HTTP ${response.status}: ${response.statusText}`);
+                Logger.error(`[MB CLIENT ERROR] Failed to send message. HTTP ${response.status}: ${response.statusText}`);
                 throw new Error(`Message sending failed: HTTP ${response.status} - ${response.statusText}`);
             }
             if (parsedResponse.status !== 'success') {
-                logger_js_1.Logger.error(`[MB CLIENT ERROR] Server returned an error: ${String(parsedResponse.description)}`);
+                Logger.error(`[MB CLIENT ERROR] Server returned an error: ${String(parsedResponse.description)}`);
                 throw new Error((_b = parsedResponse.description) !== null && _b !== void 0 ? _b : 'Unknown error from server.');
             }
-            logger_js_1.Logger.log('[MB CLIENT] Message successfully sent.');
+            Logger.log('[MB CLIENT] Message successfully sent.');
             return { ...parsedResponse, messageId };
         }
         catch (error) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] Network or timeout error:', error);
+            Logger.error('[MB CLIENT ERROR] Network or timeout error:', error);
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
             throw new Error(`Failed to send message: ${errorMessage}`);
         }
@@ -860,26 +923,26 @@ class MessageBoxClient {
      * const { txid } = await client.anointHost('https://my-messagebox.io')
      */
     async anointHost(host) {
-        logger_js_1.Logger.log('[MB CLIENT] Starting anointHost...');
+        Logger.log('[MB CLIENT] Starting anointHost...');
         try {
             if (!host.startsWith('http')) {
                 throw new Error('Invalid host URL');
             }
             const identityKey = await this.getIdentityKey();
-            logger_js_1.Logger.log('[MB CLIENT] Fields - Identity:', identityKey, 'Host:', host);
+            Logger.log('[MB CLIENT] Fields - Identity:', identityKey, 'Host:', host);
             const fields = [
                 sdk_1.Utils.toArray(identityKey, 'hex'),
                 sdk_1.Utils.toArray(host, 'utf8')
             ];
             const pushdrop = new sdk_1.PushDrop(this.walletClient);
-            logger_js_1.Logger.log('Fields:', fields.map(a => sdk_1.Utils.toHex(a)));
-            logger_js_1.Logger.log('ProtocolID:', [1, 'messagebox advertisement']);
-            logger_js_1.Logger.log('KeyID:', '1');
-            logger_js_1.Logger.log('SignAs:', 'self');
-            logger_js_1.Logger.log('anyoneCanSpend:', false);
-            logger_js_1.Logger.log('forSelf:', true);
+            Logger.log('Fields:', fields.map(a => sdk_1.Utils.toHex(a)));
+            Logger.log('ProtocolID:', [1, 'messagebox advertisement']);
+            Logger.log('KeyID:', '1');
+            Logger.log('SignAs:', 'self');
+            Logger.log('anyoneCanSpend:', false);
+            Logger.log('forSelf:', true);
             const script = await pushdrop.lock(fields, [1, 'messagebox advertisement'], '1', 'anyone', true);
-            logger_js_1.Logger.log('[MB CLIENT] PushDrop script:', script.toASM());
+            Logger.log('[MB CLIENT] PushDrop script:', script.toASM());
             const { tx, txid } = await this.walletClient.createAction({
                 description: 'Anoint host for overlay routing',
                 outputs: [{
@@ -890,13 +953,13 @@ class MessageBoxClient {
                     }],
                 options: { randomizeOutputs: false, acceptDelayedBroadcast: false }
             });
-            logger_js_1.Logger.log('[MB CLIENT] Transaction created:', txid);
+            Logger.log('[MB CLIENT] Transaction created:', txid);
             if (tx !== undefined) {
                 const broadcaster = new sdk_1.TopicBroadcaster(['tm_messagebox'], {
                     networkPreset: this.networkPreset
                 });
                 const result = await broadcaster.broadcast(sdk_1.Transaction.fromAtomicBEEF(tx));
-                logger_js_1.Logger.log('[MB CLIENT] Advertisement broadcast succeeded. TXID:', result.txid);
+                Logger.log('[MB CLIENT] Advertisement broadcast succeeded. TXID:', result.txid);
                 if (typeof result.txid !== 'string') {
                     throw new Error('Anoint failed: broadcast did not return a txid');
                 }
@@ -905,7 +968,7 @@ class MessageBoxClient {
             throw new Error('Anoint failed: failed to create action!');
         }
         catch (err) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] anointHost threw:', err);
+            Logger.error('[MB CLIENT ERROR] anointHost threw:', err);
             throw err;
         }
     }
@@ -923,7 +986,7 @@ class MessageBoxClient {
      * const { txid } = await client.revokeHost('https://my-messagebox.io')
      */
     async revokeHostAdvertisement(advertisementToken) {
-        logger_js_1.Logger.log('[MB CLIENT] Starting revokeHost...');
+        Logger.log('[MB CLIENT] Starting revokeHost...');
         const outpoint = `${advertisementToken.txid}.${advertisementToken.outputIndex}`;
         try {
             const { signableTransaction } = await this.walletClient.createAction({
@@ -965,14 +1028,14 @@ class MessageBoxClient {
                 networkPreset: this.networkPreset
             });
             const result = await broadcaster.broadcast(sdk_1.Transaction.fromAtomicBEEF(signedTx));
-            logger_js_1.Logger.log('[MB CLIENT] Revocation broadcast succeeded. TXID:', result.txid);
+            Logger.log('[MB CLIENT] Revocation broadcast succeeded. TXID:', result.txid);
             if (typeof result.txid !== 'string') {
                 throw new Error('Revoke failed: broadcast did not return a txid');
             }
             return { txid: result.txid };
         }
         catch (err) {
-            logger_js_1.Logger.error('[MB CLIENT ERROR] revokeHost threw:', err);
+            Logger.error('[MB CLIENT ERROR] revokeHost threw:', err);
             throw err;
         }
     }
@@ -988,9 +1051,16 @@ class MessageBoxClient {
      *
      * Each message is:
      * - Parsed and, if encrypted, decrypted using AES-256-GCM via BRC-2-compliant ECDH key derivation and symmetric encryption.
+     * - Automatically processed for payments: if the message includes recipient fee payments, they are internalized using `walletClient.internalizeAction()`.
      * - Returned as a normalized `PeerMessage` with readable string body content.
      *
-     * Decryption automatically derives a shared secret using the sender’s identity key and the receiver’s child private key.
+     * Payment Processing:
+     * - Detects messages that include payment data (from paid message delivery).
+     * - Automatically internalizes recipient payment outputs, allowing you to receive payments without additional API calls.
+     * - Only recipient payments are stored with messages - delivery fees are already processed by the server.
+     * - Continues processing messages even if payment internalization fails.
+     *
+     * Decryption automatically derives a shared secret using the sender's identity key and the receiver's child private key.
      * If the sender is the same as the recipient, the `counterparty` is set to `'self'`.
      *
      * @throws {Error} If no messageBox is specified, the request fails, or the server returns an error.
@@ -998,8 +1068,10 @@ class MessageBoxClient {
      * @example
      * const messages = await client.listMessages({ messageBox: 'inbox' })
      * messages.forEach(msg => console.log(msg.sender, msg.body))
+     * // Payments included with messages are automatically received
      */
     async listMessages({ messageBox, host }) {
+        var _a, _b;
         await this.assertInitialized();
         if (messageBox.trim() === '') {
             throw new Error('MessageBox cannot be empty');
@@ -1013,7 +1085,7 @@ class MessageBoxClient {
         const fetchFromHost = async (host) => {
             var _a;
             try {
-                logger_js_1.Logger.log(`[MB CLIENT] Listing messages from ${host}…`);
+                Logger.log(`[MB CLIENT] Listing messages from ${host}…`);
                 const res = await this.authFetch.fetch(`${host}/listMessages`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
@@ -1027,7 +1099,7 @@ class MessageBoxClient {
                 return data.messages;
             }
             catch (err) {
-                logger_js_1.Logger.log(`[MB CLIENT DEBUG] listMessages failed for ${host}:`, err);
+                Logger.log(`[MB CLIENT DEBUG] listMessages failed for ${host}:`, err);
                 throw err; // re-throw to be caught in the settled promise
             }
         };
@@ -1070,25 +1142,67 @@ class MessageBoxClient {
         for (const message of messages) {
             try {
                 const parsedBody = typeof message.body === 'string' ? tryParse(message.body) : message.body;
+                let messageContent = parsedBody;
+                let paymentData;
                 if (parsedBody != null &&
                     typeof parsedBody === 'object' &&
-                    typeof parsedBody.encryptedMessage === 'string') {
-                    logger_js_1.Logger.log(`[MB CLIENT] Decrypting message from ${String(message.sender)}…`);
+                    'message' in parsedBody) {
+                    messageContent = (_a = parsedBody.message) === null || _a === void 0 ? void 0 : _a.body;
+                    paymentData = parsedBody.payment;
+                }
+                // Process payment if present - server now only stores recipient payments
+                if ((paymentData === null || paymentData === void 0 ? void 0 : paymentData.tx) != null && paymentData.outputs != null) {
+                    try {
+                        Logger.log(`[MB CLIENT] Processing recipient payment in message from ${String(message.sender)}…`);
+                        // All outputs in the stored payment data are for the recipient
+                        // (delivery fees are already processed by the server)
+                        const recipientOutputs = paymentData.outputs.filter(output => output.protocol === 'wallet payment');
+                        if (recipientOutputs.length > 0) {
+                            Logger.log(`[MB CLIENT] Internalizing ${recipientOutputs.length} recipient payment output(s)…`);
+                            const internalizeResult = await this.walletClient.internalizeAction({
+                                tx: paymentData.tx,
+                                outputs: recipientOutputs,
+                                description: (_b = paymentData.description) !== null && _b !== void 0 ? _b : 'MessageBox recipient payment'
+                            });
+                            if (internalizeResult.accepted) {
+                                Logger.log('[MB CLIENT] Successfully internalized recipient payment');
+                            }
+                            else {
+                                Logger.warn('[MB CLIENT] Recipient payment internalization was not accepted');
+                            }
+                        }
+                        else {
+                            Logger.log('[MB CLIENT] No wallet payment outputs found in payment data');
+                        }
+                    }
+                    catch (paymentError) {
+                        Logger.error('[MB CLIENT ERROR] Failed to internalize recipient payment:', paymentError);
+                        // Continue processing the message even if payment fails
+                    }
+                }
+                // Handle message decryption
+                if (messageContent != null &&
+                    typeof messageContent === 'object' &&
+                    typeof messageContent.encryptedMessage === 'string') {
+                    Logger.log(`[MB CLIENT] Decrypting message from ${String(message.sender)}…`);
                     const decrypted = await this.walletClient.decrypt({
                         protocolID: [1, 'messagebox'],
                         keyID: '1',
                         counterparty: message.sender,
-                        ciphertext: sdk_1.Utils.toArray(parsedBody.encryptedMessage, 'base64')
+                        ciphertext: sdk_1.Utils.toArray(messageContent.encryptedMessage, 'base64')
                     });
                     const decryptedText = sdk_1.Utils.toUTF8(decrypted.plaintext);
                     message.body = tryParse(decryptedText);
                 }
                 else {
-                    message.body = parsedBody;
+                    // Handle both old format (direct content) and new format (message.body)
+                    message.body = messageContent != null
+                        ? (typeof messageContent === 'string' ? messageContent : messageContent)
+                        : parsedBody;
                 }
             }
             catch (err) {
-                logger_js_1.Logger.error('[MB CLIENT ERROR] Failed to parse or decrypt message in list:', err);
+                Logger.error('[MB CLIENT ERROR] Failed to parse or decrypt message in list:', err);
                 message.body = '[Error: Failed to decrypt or parse message]';
             }
         }
@@ -1123,7 +1237,7 @@ class MessageBoxClient {
         if (!Array.isArray(messageIds) || messageIds.length === 0) {
             throw new Error('Message IDs array cannot be empty');
         }
-        logger_js_1.Logger.log(`[MB CLIENT] Acknowledging messages ${JSON.stringify(messageIds)}…`);
+        Logger.log(`[MB CLIENT] Acknowledging messages ${JSON.stringify(messageIds)}…`);
         let hosts = host != null ? [host] : [];
         if (hosts.length === 0) {
             // 1. Determine all hosts (advertised + default)
@@ -1144,11 +1258,11 @@ class MessageBoxClient {
                 const data = await res.json();
                 if (data.status === 'error')
                     throw new Error(data.description);
-                logger_js_1.Logger.log(`[MB CLIENT] Acknowledged on ${host}`);
+                Logger.log(`[MB CLIENT] Acknowledged on ${host}`);
                 return data.status;
             }
             catch (err) {
-                logger_js_1.Logger.warn(`[MB CLIENT WARN] acknowledgeMessage failed for ${host}:`, err);
+                Logger.warn(`[MB CLIENT WARN] acknowledgeMessage failed for ${host}:`, err);
                 return null;
             }
         };
@@ -1166,6 +1280,512 @@ class MessageBoxClient {
         }
         throw new Error(`Failed to acknowledge messages on all hosts: ${errs.map(e => String(e)).join('; ')}`);
     }
+    // ===========================
+    // PERMISSION MANAGEMENT METHODS
+    // ===========================
+    /**
+     * @method setMessageBoxPermission
+     * @async
+     * @param {SetMessageBoxPermissionParams} params - Permission configuration
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<void>} Permission status after setting
+     *
+     * @description
+     * Sets permission for receiving messages in a specific messageBox.
+     * Can set sender-specific permissions or box-wide defaults.
+     *
+     * @example
+     * // Set box-wide default: allow notifications for 10 sats
+     * await client.setMessageBoxPermission({ messageBox: 'notifications', recipientFee: 10 })
+     *
+     * // Block specific sender
+     * await client.setMessageBoxPermission({
+     *   messageBox: 'notifications',
+     *   sender: '03abc123...',
+     *   recipientFee: -1
+     * })
+     */
+    async setMessageBoxPermission(params, overrideHost) {
+        await this.assertInitialized();
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : this.host;
+        Logger.log('[MB CLIENT] Setting messageBox permission...');
+        const response = await this.authFetch.fetch(`${finalHost}/permissions/set`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                messageBox: params.messageBox,
+                recipientFee: params.recipientFee,
+                ...(params.sender != null && { sender: params.sender })
+            })
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Failed to set permission: HTTP ${response.status} - ${String(errorData.description) !== '' ? String(errorData.description) : response.statusText}`);
+        }
+        const { status, description } = await response.json();
+        if (status === 'error') {
+            throw new Error(description !== null && description !== void 0 ? description : 'Failed to set permission');
+        }
+    }
+    /**
+     * @method getMessageBoxPermission
+     * @async
+     * @param {GetMessageBoxPermissionParams} params - Permission query parameters
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<MessageBoxPermission | null>} Permission data (null if not set)
+     *
+     * @description
+     * Gets current permission data for a sender/messageBox combination.
+     * Returns null if no permission is set.
+     *
+     * @example
+     * const status = await client.getMessageBoxPermission({
+     *   recipient: '03def456...',
+     *   messageBox: 'notifications',
+     *   sender: '03abc123...'
+     * })
+     */
+    async getMessageBoxPermission(params, overrideHost) {
+        var _a;
+        await this.assertInitialized();
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : await this.resolveHostForRecipient(params.recipient);
+        const queryParams = new URLSearchParams({
+            recipient: params.recipient,
+            messageBox: params.messageBox,
+            ...(params.sender != null && { sender: params.sender })
+        });
+        Logger.log('[MB CLIENT] Getting messageBox permission...');
+        const response = await this.authFetch.fetch(`${finalHost}/permissions/get?${queryParams.toString()}`, {
+            method: 'GET'
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Failed to get permission: HTTP ${response.status} - ${String(errorData.description) !== '' ? String(errorData.description) : response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.status === 'error') {
+            throw new Error((_a = data.description) !== null && _a !== void 0 ? _a : 'Failed to get permission');
+        }
+        return data.permission;
+    }
+    /**
+     * @method getMessageBoxQuote
+     * @async
+     * @param {GetQuoteParams} params - Quote request parameters
+     * @returns {Promise<MessageBoxQuote>} Fee quote and permission status
+     *
+     * @description
+     * Gets a fee quote for sending a message, including delivery and recipient fees.
+     *
+     * @example
+     * const quote = await client.getMessageBoxQuote({
+     *   recipient: '03def456...',
+     *   messageBox: 'notifications'
+     * })
+     */
+    async getMessageBoxQuote(params, overrideHost) {
+        var _a;
+        await this.assertInitialized();
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : await this.resolveHostForRecipient(params.recipient);
+        const queryParams = new URLSearchParams({
+            recipient: params.recipient,
+            messageBox: params.messageBox
+        });
+        Logger.log('[MB CLIENT] Getting messageBox quote...');
+        const response = await this.authFetch.fetch(`${finalHost}/permissions/quote?${queryParams.toString()}`, {
+            method: 'GET'
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Failed to get quote: HTTP ${response.status} - ${(_a = String(errorData.description)) !== null && _a !== void 0 ? _a : response.statusText}`);
+        }
+        const { status, description, quote } = await response.json();
+        if (status === 'error') {
+            throw new Error(description !== null && description !== void 0 ? description : 'Failed to get quote');
+        }
+        const deliveryAgentIdentityKey = response.headers.get('x-bsv-auth-identity-key');
+        if (deliveryAgentIdentityKey == null) {
+            throw new Error('Failed to get quote: Delivery agent did not provide their identity key');
+        }
+        return {
+            recipientFee: quote.recipientFee,
+            deliveryFee: quote.deliveryFee,
+            deliveryAgentIdentityKey
+        };
+    }
+    /**
+     * @method listMessageBoxPermissions
+     * @async
+     * @param {ListPermissionsParams} [params] - Optional filtering and pagination parameters
+     * @returns {Promise<MessageBoxPermission[]>} List of current permissions
+     *
+     * @description
+     * Lists permissions for the authenticated user's messageBoxes with optional pagination.
+     *
+     * @example
+     * // List all permissions
+     * const all = await client.listMessageBoxPermissions()
+     *
+     * // List only notification permissions with pagination
+     * const notifications = await client.listMessageBoxPermissions({
+     *   messageBox: 'notifications',
+     *   limit: 50,
+     *   offset: 0
+     * })
+     */
+    async listMessageBoxPermissions(params, overrideHost) {
+        var _a;
+        await this.assertInitialized();
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : this.host;
+        const queryParams = new URLSearchParams();
+        if ((params === null || params === void 0 ? void 0 : params.messageBox) != null) {
+            queryParams.set('message_box', params.messageBox);
+        }
+        if ((params === null || params === void 0 ? void 0 : params.limit) !== undefined) {
+            queryParams.set('limit', params.limit.toString());
+        }
+        if ((params === null || params === void 0 ? void 0 : params.offset) !== undefined) {
+            queryParams.set('offset', params.offset.toString());
+        }
+        Logger.log('[MB CLIENT] Listing messageBox permissions with params:', queryParams.toString());
+        const response = await this.authFetch.fetch(`${finalHost}/permissions/list?${queryParams.toString()}`, {
+            method: 'GET'
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Failed to list permissions: HTTP ${response.status} - ${String(errorData.description) !== '' ? String(errorData.description) : response.statusText}`);
+        }
+        const data = await response.json();
+        if (data.status === 'error') {
+            throw new Error((_a = data.description) !== null && _a !== void 0 ? _a : 'Failed to list permissions');
+        }
+        return data.permissions.map((p) => ({
+            sender: p.sender,
+            messageBox: p.message_box,
+            recipientFee: p.recipient_fee,
+            status: MessageBoxClient.getStatusFromFee(p.recipient_fee),
+            createdAt: p.created_at,
+            updatedAt: p.updated_at
+        }));
+    }
+    // ===========================
+    // NOTIFICATION CONVENIENCE METHODS
+    // ===========================
+    /**
+     * @method allowNotificationsFromPeer
+     * @async
+     * @param {PubKeyHex} identityKey - Sender's identity key to allow
+     * @param {number} [recipientFee=0] - Fee to charge (0 for always allow)
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<void>} Permission status after allowing
+     *
+     * @description
+     * Convenience method to allow notifications from a specific peer.
+     *
+     * @example
+     * await client.allowNotificationsFromPeer('03abc123...') // Always allow
+     * await client.allowNotificationsFromPeer('03def456...', 5) // Allow for 5 sats
+     */
+    async allowNotificationsFromPeer(identityKey, recipientFee = 0, overrideHost) {
+        await this.setMessageBoxPermission({
+            messageBox: 'notifications',
+            sender: identityKey,
+            recipientFee
+        }, overrideHost);
+    }
+    /**
+     * @method denyNotificationsFromPeer
+     * @async
+     * @param {PubKeyHex} identityKey - Sender's identity key to block
+     * @returns {Promise<void>} Permission status after denying
+     *
+     * @description
+     * Convenience method to block notifications from a specific peer.
+     *
+     * @example
+     * await client.denyNotificationsFromPeer('03spam123...')
+     */
+    async denyNotificationsFromPeer(identityKey, overrideHost) {
+        await this.setMessageBoxPermission({
+            messageBox: 'notifications',
+            sender: identityKey,
+            recipientFee: -1
+        }, overrideHost);
+    }
+    /**
+     * @method checkPeerNotificationStatus
+     * @async
+     * @param {PubKeyHex} identityKey - Sender's identity key to check
+     * @returns {Promise<MessageBoxPermission>} Current permission status
+     *
+     * @description
+     * Convenience method to check notification permission for a specific peer.
+     *
+     * @example
+     * const status = await client.checkPeerNotificationStatus('03abc123...')
+     * console.log(status.allowed) // true/false
+     */
+    async checkPeerNotificationStatus(identityKey, overrideHost) {
+        const myIdentityKey = await this.getIdentityKey();
+        return await this.getMessageBoxPermission({
+            recipient: myIdentityKey,
+            messageBox: 'notifications',
+            sender: identityKey
+        }, overrideHost);
+    }
+    /**
+     * @method listPeerNotifications
+     * @async
+     * @returns {Promise<MessageBoxPermission[]>} List of notification permissions
+     *
+     * @description
+     * Convenience method to list all notification permissions.
+     *
+     * @example
+     * const notifications = await client.listPeerNotifications()
+     */
+    async listPeerNotifications(overrideHost) {
+        return await this.listMessageBoxPermissions({ messageBox: 'notifications' }, overrideHost);
+    }
+    /**
+     * @method sendNotification
+     * @async
+     * @param {PubKeyHex} recipient - Recipient's identity key
+     * @param {string | object} body - Notification content
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<SendMessageResponse>} Send result
+     *
+     * @description
+     * Convenience method to send a notification with automatic quote fetching and payment handling.
+     * Automatically determines the required payment amount and creates the payment if needed.
+     *
+     * @example
+     * // Send notification (auto-determines payment needed)
+     * await client.sendNotification('03def456...', 'Hello!')
+     *
+     * // Send with maximum payment limit for safety
+     * await client.sendNotification('03def456...', { title: 'Alert', body: 'Important update' }, 50)
+     */
+    async sendNotification(recipient, body, overrideHost) {
+        await this.assertInitialized();
+        // Use sendMessage with permission checking enabled
+        // This eliminates duplication of quote fetching and payment logic
+        return await this.sendMessage({
+            recipient,
+            messageBox: 'notifications',
+            body,
+            checkPermissions: true
+        }, overrideHost);
+    }
+    /**
+     * Register a device for FCM push notifications.
+     *
+     * @async
+     * @param {DeviceRegistrationParams} params - Device registration parameters
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<DeviceRegistrationResponse>} Registration response
+     *
+     * @description
+     * Registers a device with the message box server to receive FCM push notifications.
+     * The FCM token is obtained from Firebase SDK on the client side.
+     *
+     * @example
+     * const result = await client.registerDevice({
+     *   fcmToken: 'eBo8F...',
+     *   platform: 'ios',
+     *   deviceId: 'iPhone15Pro'
+     * })
+     */
+    async registerDevice(params, overrideHost) {
+        var _a, _b, _c, _d, _e;
+        await this.assertInitialized();
+        if (params.fcmToken == null || params.fcmToken.trim() === '') {
+            throw new Error('fcmToken is required and must be a non-empty string');
+        }
+        // Validate platform if provided
+        const validPlatforms = ['ios', 'android', 'web'];
+        if (params.platform != null && !validPlatforms.includes(params.platform)) {
+            throw new Error('platform must be one of: ios, android, web');
+        }
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : this.host;
+        Logger.log('[MB CLIENT] Registering device for FCM notifications...');
+        const response = await this.authFetch.fetch(`${finalHost}/registerDevice`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                fcmToken: params.fcmToken.trim(),
+                deviceId: (_b = (_a = params.deviceId) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : undefined,
+                platform: (_c = params.platform) !== null && _c !== void 0 ? _c : undefined
+            })
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            const description = (_d = String(errorData.description)) !== null && _d !== void 0 ? _d : response.statusText;
+            throw new Error(`Failed to register device: HTTP ${response.status} - ${description}`);
+        }
+        const data = await response.json();
+        if (data.status === 'error') {
+            throw new Error((_e = data.description) !== null && _e !== void 0 ? _e : 'Failed to register device');
+        }
+        Logger.log('[MB CLIENT] Device registered successfully');
+        return {
+            status: data.status,
+            message: data.message,
+            deviceId: data.deviceId
+        };
+    }
+    /**
+     * List all registered devices for push notifications.
+     *
+     * @async
+     * @param {string} [overrideHost] - Optional host override
+     * @returns {Promise<RegisteredDevice[]>} Array of registered devices
+     *
+     * @description
+     * Retrieves all devices registered by the authenticated user for FCM push notifications.
+     * Only shows devices belonging to the current user (authenticated via AuthFetch).
+     *
+     * @example
+     * const devices = await client.listRegisteredDevices()
+     * console.log(`Found ${devices.length} registered devices`)
+     * devices.forEach(device => {
+     *   console.log(`Device: ${device.platform} - ${device.fcmToken}`)
+     * })
+     */
+    async listRegisteredDevices(overrideHost) {
+        var _a, _b;
+        await this.assertInitialized();
+        const finalHost = overrideHost !== null && overrideHost !== void 0 ? overrideHost : this.host;
+        Logger.log('[MB CLIENT] Listing registered devices...');
+        const response = await this.authFetch.fetch(`${finalHost}/devices`, {
+            method: 'GET'
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            const description = (_a = String(errorData.description)) !== null && _a !== void 0 ? _a : response.statusText;
+            throw new Error(`Failed to list devices: HTTP ${response.status} - ${description}`);
+        }
+        const data = await response.json();
+        if (data.status === 'error') {
+            throw new Error((_b = data.description) !== null && _b !== void 0 ? _b : 'Failed to list devices');
+        }
+        Logger.log(`[MB CLIENT] Found ${data.devices.length} registered devices`);
+        return data.devices;
+    }
+    // ===========================
+    // PRIVATE HELPER METHODS
+    // ===========================
+    static getStatusFromFee(fee) {
+        if (fee === -1)
+            return 'blocked';
+        if (fee === 0)
+            return 'always_allow';
+        return 'payment_required';
+    }
+    /**
+     * Creates payment transaction for message delivery fees
+     * TODO: Consider consolidating payment generating logic with a util PeerPayClient can use as well.
+     * @private
+     * @param {string} recipient - Recipient identity key
+     * @param {MessageBoxQuote} quote - Fee quote with delivery and recipient fees
+     * @param {string} description - Description for the payment transaction
+     * @returns {Promise<Payment>} Payment transaction data
+     */
+    async createMessagePayment(recipient, quote, description = 'MessageBox delivery payment') {
+        if (quote.recipientFee <= 0 && quote.deliveryFee <= 0) {
+            throw new Error('No payment required');
+        }
+        Logger.log(`[MB CLIENT] Creating payment transaction for ${quote.recipientFee} sats (delivery: ${quote.deliveryFee}, recipient: ${quote.recipientFee})`);
+        const outputs = [];
+        const createActionOutputs = [];
+        // Get sender identity key for remittance data
+        const senderIdentityKey = await this.getIdentityKey();
+        // Add server delivery fee output if > 0
+        let outputIndex = 0;
+        if (quote.deliveryFee > 0) {
+            const derivationPrefix = sdk_1.Utils.toBase64((0, sdk_1.Random)(32));
+            const derivationSuffix = sdk_1.Utils.toBase64((0, sdk_1.Random)(32));
+            // Get host's derived public key
+            const { publicKey: derivedKeyResult } = await this.walletClient.getPublicKey({
+                protocolID: [2, '3241645161d8'],
+                keyID: `${derivationPrefix} ${derivationSuffix}`,
+                counterparty: quote.deliveryAgentIdentityKey
+            });
+            // Create locking script using host's public key
+            const lockingScript = new sdk_1.P2PKH().lock(sdk_1.PublicKey.fromString(derivedKeyResult).toAddress()).toHex();
+            // Add to createAction outputs
+            createActionOutputs.push({
+                satoshis: quote.deliveryFee,
+                lockingScript,
+                outputDescription: 'MessageBox server delivery fee',
+                customInstructions: JSON.stringify({
+                    derivationPrefix,
+                    derivationSuffix,
+                    recipientIdentityKey: quote.deliveryAgentIdentityKey
+                })
+            });
+            outputs.push({
+                outputIndex: outputIndex++,
+                protocol: 'wallet payment',
+                paymentRemittance: {
+                    derivationPrefix,
+                    derivationSuffix,
+                    senderIdentityKey
+                }
+            });
+        }
+        // Add recipient fee output if > 0
+        if (quote.recipientFee > 0) {
+            const derivationPrefix = sdk_1.Utils.toBase64((0, sdk_1.Random)(32));
+            const derivationSuffix = sdk_1.Utils.toBase64((0, sdk_1.Random)(32));
+            // Get a derived public key for the recipient that "anyone" can verify
+            const anyoneWallet = new sdk_1.ProtoWallet('anyone');
+            const { publicKey: derivedKeyResult } = await anyoneWallet.getPublicKey({
+                protocolID: [2, '3241645161d8'],
+                keyID: `${derivationPrefix} ${derivationSuffix}`,
+                counterparty: recipient
+            });
+            if (derivedKeyResult == null || derivedKeyResult.trim() === '') {
+                throw new Error('Failed to derive recipient\'s public key');
+            }
+            // Create locking script using recipient's public key
+            const lockingScript = new sdk_1.P2PKH().lock(sdk_1.PublicKey.fromString(derivedKeyResult).toAddress()).toHex();
+            // Add to createAction outputs
+            createActionOutputs.push({
+                satoshis: quote.recipientFee,
+                lockingScript,
+                outputDescription: 'Recipient message fee',
+                customInstructions: JSON.stringify({
+                    derivationPrefix,
+                    derivationSuffix,
+                    recipientIdentityKey: recipient
+                })
+            });
+            outputs.push({
+                outputIndex: outputIndex++,
+                protocol: 'wallet payment',
+                paymentRemittance: {
+                    derivationPrefix,
+                    derivationSuffix,
+                    senderIdentityKey
+                }
+            });
+        }
+        const { tx } = await this.walletClient.createAction({
+            description,
+            outputs: createActionOutputs,
+            options: { randomizeOutputs: false, acceptDelayedBroadcast: false }
+        });
+        if (tx == null) {
+            throw new Error('Failed to create payment transaction');
+        }
+        return {
+            tx,
+            outputs,
+            description
+            // labels
+        };
+    }
 }
 exports.MessageBoxClient = MessageBoxClient;
 //# sourceMappingURL=MessageBoxClient.js.map