chia-agent 14.3.2 → 14.3.4

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [14.3.4]
+### Breaking change
+- Changed `daemon.connect()` API signature from `connect(url?, timeoutMs?)` to `connect(url?, options?)`
+  - All connection options are now consolidated into a single `options` parameter
+  - Existing code calling `connect()` without parameters remains compatible
+### Changed
+- Improved logger system
+  - Added logger instance caching
+  - Added support for multiple loggers with per-instance configuration
+  - Added `NullWriter` for complete log suppression
+  - Updated `ConsoleWriter` to use proper console methods
+  - Added `trace` log level
+  - Added environment variable support: `LOG_LEVEL` and `LOG_SUPPRESS`
+  - Refactored API to use named loggers
+  - Added customizable log formatting with built-in formatters
+- Auto-reconnection is now enabled by default
+### Fixed
+- Fixed WebSocket message handling issues
+  - Added timeout handling for sent messages (default 30s)
+  - Fixed connection state check to use actual WebSocket readyState
+  - Preserved event listeners on connection close for reconnection support
+  - Added proper cleanup of message timeouts on response
+- Fixed RPC agent to properly handle HTTP connections with explicit host/port
+### Added
+- Added automatic retry/reconnection mechanism for WebSocket connection attempts
+  - Exponential backoff with configurable parameters
+  - Configurable retry parameters (maxAttempts, initialDelay, maxDelay, backoffMultiplier)
+  - Automatic re-subscription to services after reconnection
+  - Same retry configuration applies to both initial connection and reconnection
+### Internal change
+- Removed `TDestination` type in favor of Writer-based approach
+
+## [14.3.3]
+### Changed
+- The default service name which [`Daemon`](./src/daemon/index.ts) client tries to register is now `wallet_ui`.  
+  Previously `chia_agent` service and optionally `wallet_ui` service were registered to `chia-blockchain`'s `Daemon`.  
+
 ## [14.3.2]
 ### Changed
 - Error logs are generated when
@@ -1715,6 +1752,8 @@ daemon.sendMessage(destination, get_block_record_by_height_command, data);
 Initial release.
 
 <!-- [Unreleased]: https://github.com/Chia-Mine/chia-agent/compare/v0.0.1...v0.0.2 -->
+[14.3.4]: https://github.com/Chia-Mine/chia-agent/compare/v14.3.3...v14.3.4
+[14.3.3]: https://github.com/Chia-Mine/chia-agent/compare/v14.3.2...v14.3.3
 [14.3.2]: https://github.com/Chia-Mine/chia-agent/compare/v14.3.1...v14.3.2
 [14.3.1]: https://github.com/Chia-Mine/chia-agent/compare/v14.3.0...v14.3.1
 [14.3.0]: https://github.com/Chia-Mine/chia-agent/compare/v14.2.2...v14.3.0

package/README.md

@@ -113,6 +113,33 @@ setTimeout(async () => {
  */
 ```
 
+## Logging
+The logger system supports multiple log levels and formatters:
+
+```js
+const {setLogLevel, getLogger, setDefaultFormatter, simpleLogFormatter} = require("chia-agent");
+
+// Set log level (case-insensitive)
+setLogLevel("DEBUG"); // "error", "warning", "info", "debug", "trace", "none"
+
+// Use built-in formatters
+setDefaultFormatter(simpleLogFormatter); // Simple format without timestamp
+
+// Custom formatter
+const myFormatter = (context) => {
+  return `[${context.level}] ${context.message}`;
+};
+setDefaultFormatter(myFormatter);
+
+// Named loggers
+const logger = getLogger("MyModule");
+logger.info("Module initialized");
+
+// Per-logger configuration
+logger.setLogLevel("debug");
+logger.setFormatter(myFormatter);
+```
+
 ## API Reference
 [See Documentation here](https://github.com/Chia-Mine/chia-agent/blob/main/src/api/README.md)
 

package/daemon/connection.js

@@ -42,16 +42,16 @@ function open(url, timeoutMs) {
                 reject(err);
             }
         };
-        ws.addEventListener("open", (openEvent) => {
+        ws.on("open", (openEvent) => {
             opened = true;
-            ws.removeEventListener("error", onOpenError);
+            ws.off("error", onOpenError);
             if (timer !== null) {
                 clearTimeout(timer);
                 timer = null;
                 resolve({ ws, openEvent });
             }
         });
-        ws.addEventListener("error", onOpenError);
+        ws.on("error", onOpenError);
     });
 }
 exports.open = open;

package/daemon/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { CloseEvent, ErrorEvent, MessageEvent, Event } from "ws";
 import * as WS from "ws";
 import { WsMessage } from "../api/ws";
@@ -7,12 +8,27 @@ export type WsEvent = Event | MessageEvent | ErrorEvent | CloseEvent;
 export type EventListener<T = WsEvent> = (ev: T) => unknown;
 type EventListenerOf<T> = T extends "open" ? EventListener<Event> : T extends "message" ? EventListener<MessageEvent> : T extends "error" ? EventListener<ErrorEvent> : T extends "close" ? EventListener<CloseEvent> : never;
 export type MessageListener<D extends WsMessage> = (msg: D) => unknown;
-export declare function getDaemon(): Daemon;
+export interface RetryOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+export interface ConnectOptions {
+    timeoutMs?: number;
+    autoReconnect?: boolean;
+    retryOptions?: RetryOptions;
+}
+export declare function getDaemon(serviceName?: string): Daemon;
 declare class Daemon {
     protected _socket: WS | null;
     protected _connectedUrl: string;
     protected _responseQueue: {
-        [request_id: string]: (value: unknown) => void;
+        [request_id: string]: {
+            resolver: (value: unknown) => void;
+            rejecter: (error: unknown) => void;
+            timeout: NodeJS.Timeout;
+        };
     };
     protected _openEventListeners: Array<(e: Event) => unknown>;
     protected _messageEventListeners: Array<(e: MessageEvent) => unknown>;
@@ -22,17 +38,26 @@ declare class Daemon {
     protected _closing: boolean;
     protected _onClosePromise: (() => unknown) | undefined;
     protected _subscriptions: string[];
+    protected _serviceName: string;
+    protected _autoReconnect: boolean;
+    protected _retryOptions: Required<RetryOptions>;
+    protected _timeoutMs: number;
+    protected _reconnectAttempts: number;
+    protected _reconnectTimer: NodeJS.Timeout | null;
+    protected _lastConnectionUrl: string;
+    protected _isReconnecting: boolean;
     get connected(): boolean;
     get closing(): boolean;
-    constructor();
+    constructor(serviceName?: string);
+    protected onRejection(e: unknown): null;
     /**
      * Connect to local daemon via websocket.
-     * @param daemonServerURL
-     * @param timeoutMs
+     * @param daemonServerURL - The websocket URL to connect to. If not provided, uses config values.
+     * @param options - Connection options including timeout, reconnect settings, and retry settings
      */
-    connect(daemonServerURL?: string, timeoutMs?: number): Promise<boolean>;
+    connect(daemonServerURL?: string, options?: ConnectOptions): Promise<boolean>;
     close(): Promise<unknown>;
-    sendMessage<M = unknown>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
+    sendMessage<M = unknown>(destination: string, command: string, data?: Record<string, unknown>, timeoutMs?: number): Promise<M>;
     createMessageTemplate(command: string, destination: string, data: Record<string, unknown>): {
         command: string;
         data: Record<string, unknown>;
@@ -59,6 +84,7 @@ declare class Daemon {
     protected onClose(event: CloseEvent): void;
     protected onPing(): void;
     protected onPong(): void;
+    protected _attemptReconnection(previousSubscriptions: string[]): void;
 }
 export type TDaemon = InstanceType<typeof Daemon>;
 export {};

package/daemon/index.js

@@ -10,17 +10,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemon = void 0;
+const WS = require("ws");
 const crypto_1 = require("crypto");
 const logger_1 = require("../logger");
 const connection_1 = require("./connection");
 const index_1 = require("../config/index");
-const chia_agent_service = "chia_agent";
+const DEFAULT_SERVICE_NAME = "wallet_ui";
+const DEFAULT_AUTO_RECONNECT = true;
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 5,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 1.5,
+};
 let daemon = null;
-function getDaemon() {
+function getDaemon(serviceName) {
     if (daemon) {
         return daemon;
     }
-    return daemon = new Daemon();
+    return (daemon = new Daemon(serviceName));
 }
 exports.getDaemon = getDaemon;
 // Gracefully disconnect from remote daemon server on Ctrl+C.
@@ -48,12 +57,14 @@ const onProcessExit = () => {
 process.addListener("SIGINT", onProcessExit);
 class Daemon {
     get connected() {
-        return Boolean(this._connectedUrl);
+        return (Boolean(this._connectedUrl) &&
+            this._socket !== null &&
+            this._socket.readyState === WS.OPEN);
     }
     get closing() {
         return this._closing;
     }
-    constructor() {
+    constructor(serviceName) {
         this._socket = null;
         this._connectedUrl = "";
         this._responseQueue = {};
@@ -64,19 +75,51 @@ class Daemon {
         this._messageListeners = {};
         this._closing = false;
         this._subscriptions = [];
+        this._serviceName = DEFAULT_SERVICE_NAME;
+        this._autoReconnect = DEFAULT_AUTO_RECONNECT;
+        this._retryOptions = DEFAULT_RETRY_OPTIONS;
+        this._timeoutMs = DEFAULT_TIMEOUT_MS;
+        this._reconnectAttempts = 0;
+        this._reconnectTimer = null;
+        this._lastConnectionUrl = "";
+        this._isReconnecting = false;
         this.onOpen = this.onOpen.bind(this);
         this.onError = this.onError.bind(this);
         this.onMessage = this.onMessage.bind(this);
         this.onClose = this.onClose.bind(this);
         this.onPing = this.onPing.bind(this);
         this.onPong = this.onPong.bind(this);
+        this.onRejection = this.onRejection.bind(this);
+        if (serviceName) {
+            this._serviceName = serviceName;
+        }
+    }
+    onRejection(e) {
+        if (typeof e === "string") {
+            (0, logger_1.getLogger)().error(`Error: ${e}`);
+        }
+        else if (e instanceof Error) {
+            (0, logger_1.getLogger)().error(`Error ${e.name}: ${e.message}`);
+            if (e.stack) {
+                (0, logger_1.getLogger)().error(e.stack);
+            }
+        }
+        else {
+            try {
+                (0, logger_1.getLogger)().error(`Error: ${JSON.stringify(e)}`);
+            }
+            catch (_e) {
+                (0, logger_1.getLogger)().error("Unknown error");
+            }
+        }
+        return null;
     }
     /**
      * Connect to local daemon via websocket.
-     * @param daemonServerURL
-     * @param timeoutMs
+     * @param daemonServerURL - The websocket URL to connect to. If not provided, uses config values.
+     * @param options - Connection options including timeout, reconnect settings, and retry settings
      */
-    connect(daemonServerURL, timeoutMs) {
+    connect(daemonServerURL, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!daemonServerURL) {
                 const config = (0, index_1.getConfig)();
@@ -84,6 +127,19 @@ class Daemon {
                 const daemonPort = config["/ui/daemon_port"];
                 daemonServerURL = `wss://${daemonHost}:${daemonPort}`;
             }
+            // Extract options with defaults
+            const timeoutMs = (options === null || options === void 0 ? void 0 : options.timeoutMs) || this._timeoutMs;
+            // Store timeout for reconnection attempts
+            if ((options === null || options === void 0 ? void 0 : options.timeoutMs) !== undefined) {
+                this._timeoutMs = options.timeoutMs;
+            }
+            // Update settings from options
+            if ((options === null || options === void 0 ? void 0 : options.autoReconnect) !== undefined) {
+                this._autoReconnect = options.autoReconnect;
+            }
+            if ((options === null || options === void 0 ? void 0 : options.retryOptions) !== undefined) {
+                this._retryOptions = Object.assign(Object.assign({}, DEFAULT_RETRY_OPTIONS), options.retryOptions);
+            }
             if (this._connectedUrl === daemonServerURL) {
                 return true;
             }
@@ -91,33 +147,65 @@ class Daemon {
                 (0, logger_1.getLogger)().error("Connection is still active. Please close living connection first");
                 return false;
             }
-            (0, logger_1.getLogger)().debug(`Opening websocket connection to ${daemonServerURL}`);
-            const result = yield (0, connection_1.open)(daemonServerURL, timeoutMs);
-            this._socket = result.ws;
-            this._socket.addEventListener("error", this.onError);
-            this._socket.addEventListener("message", this.onMessage);
-            this._socket.addEventListener("close", this.onClose);
-            this._socket.addListener("ping", this.onPing);
-            this._socket.addListener("pong", this.onPong);
-            yield this.onOpen(result.openEvent, daemonServerURL);
-            return true;
+            // Store URL for reconnection
+            this._lastConnectionUrl = daemonServerURL;
+            // Attempt connection with retry logic
+            let lastError;
+            for (let attempt = 1; attempt <= this._retryOptions.maxAttempts; attempt++) {
+                (0, logger_1.getLogger)().debug(`Opening websocket connection to ${daemonServerURL} (attempt ${attempt}/${this._retryOptions.maxAttempts})`);
+                const result = yield (0, connection_1.open)(daemonServerURL, timeoutMs).catch((error) => {
+                    lastError = error;
+                    return null;
+                });
+                if (result) {
+                    this._socket = result.ws;
+                    this._socket.on("error", this.onError);
+                    this._socket.addEventListener("message", this.onMessage);
+                    this._socket.on("close", this.onClose);
+                    this._socket.on("ping", this.onPing);
+                    this._socket.on("pong", this.onPong);
+                    // Call onOpen but don't check result (maintain original behavior)
+                    yield this.onOpen(result.openEvent, daemonServerURL).catch(this.onRejection);
+                    return true;
+                }
+                // If not the last attempt, wait before retrying
+                if (attempt < this._retryOptions.maxAttempts) {
+                    const delay = Math.min(this._retryOptions.initialDelay *
+                        Math.pow(this._retryOptions.backoffMultiplier, attempt - 1), this._retryOptions.maxDelay);
+                    (0, logger_1.getLogger)().info(`Connection attempt ${attempt} failed. Retrying in ${delay}ms...`);
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+            // All attempts failed
+            (0, logger_1.getLogger)().error(`Failed to connect after ${this._retryOptions.maxAttempts} attempts`);
+            this.onRejection(lastError);
+            return false;
         });
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            return new Promise(((resolve) => {
+            return new Promise((resolve) => {
                 if (this._closing || !this._socket) {
                     return;
                 }
+                // Cancel any pending reconnection
+                if (this._reconnectTimer) {
+                    clearTimeout(this._reconnectTimer);
+                    this._reconnectTimer = null;
+                }
+                // Disable reconnection for manual close
+                this._autoReconnect = false;
+                this._isReconnecting = false;
                 (0, logger_1.getLogger)().debug("Closing web socket connection");
                 this._socket.close();
                 this._closing = true;
+                this._connectedUrl = "";
                 this._onClosePromise = resolve; // Resolved in onClose function.
-            }));
+            });
         });
     }
-    sendMessage(destination, command, data) {
-        return __awaiter(this, void 0, void 0, function* () {
+    sendMessage(destination_1, command_1, data_1) {
+        return __awaiter(this, arguments, void 0, function* (destination, command, data, timeoutMs = 30000) {
             return new Promise((resolve, reject) => {
                 if (!this.connected || !this._socket) {
                     (0, logger_1.getLogger)().error("Tried to send message without active connection");
@@ -126,13 +214,32 @@ class Daemon {
                 }
                 const message = this.createMessageTemplate(command, destination, data || {});
                 const reqId = message.request_id;
-                this._responseQueue[reqId] = resolve;
-                (0, logger_1.getLogger)().debug(`Sending message. dest=${destination} command=${command} reqId=${reqId}`);
+                // Set up timeout
+                const timeout = setTimeout(() => {
+                    const entry = this._responseQueue[reqId];
+                    if (entry) {
+                        delete this._responseQueue[reqId];
+                        entry.rejecter(new Error(`Message timeout after ${timeoutMs}ms. dest=${destination} command=${command} reqId=${reqId}`));
+                    }
+                }, timeoutMs);
+                this._responseQueue[reqId] = {
+                    resolver: resolve,
+                    rejecter: reject,
+                    timeout,
+                };
+                (0, logger_1.getLogger)().debug(`Sending Ws message. dest=${destination} command=${command} reqId=${reqId}`);
                 const messageStr = JSON.stringify(message);
                 this._socket.send(messageStr, (err) => {
                     if (err) {
                         (0, logger_1.getLogger)().error(`Error while sending message: ${messageStr}`);
                         (0, logger_1.getLogger)().error(JSON.stringify(err));
+                        // Clean up on send error
+                        const entry = this._responseQueue[reqId];
+                        if (entry) {
+                            clearTimeout(entry.timeout);
+                            delete this._responseQueue[reqId];
+                            reject(err);
+                        }
                     }
                 });
             });
@@ -143,7 +250,7 @@ class Daemon {
             command,
             data,
             ack: false,
-            origin: chia_agent_service,
+            origin: this._serviceName,
             destination,
             request_id: (0, crypto_1.randomBytes)(32).toString("hex"),
         };
@@ -154,23 +261,28 @@ class Daemon {
                 (0, logger_1.getLogger)().error(`Tried to subscribe '${service}' without active connection`);
                 throw new Error("Not connected");
             }
-            if (this._subscriptions.findIndex(s => s === service) > -1) {
+            if (this._subscriptions.findIndex((s) => s === service) > -1) {
                 return {
                     command: "register_service",
                     data: { success: true },
                     ack: true,
                     origin: "daemon",
-                    destination: chia_agent_service,
+                    destination: service,
                     request_id: "",
                 };
             }
             let error;
-            const result = yield this.sendMessage("daemon", "register_service", { service }).catch(e => {
+            const result = yield this.sendMessage("daemon", "register_service", {
+                service,
+            }).catch((e) => {
                 error = e;
                 return null;
             });
             if (error || !result) {
                 (0, logger_1.getLogger)().error("Failed to register agent service to daemon");
+                (0, logger_1.getLogger)().error(error instanceof Error
+                    ? `${error.name}: ${error.message}`
+                    : JSON.stringify(error));
                 throw new Error("Subscribe failed");
             }
             this._subscriptions.push(service);
@@ -241,7 +353,7 @@ class Daemon {
         if (!listeners) {
             return;
         }
-        const index = listeners.findIndex(l => l === listener);
+        const index = listeners.findIndex((l) => l === listener);
         if (index > -1) {
             listeners.splice(index, 1);
         }
@@ -253,13 +365,13 @@ class Daemon {
         return __awaiter(this, void 0, void 0, function* () {
             (0, logger_1.getLogger)().info("ws connection opened");
             this._connectedUrl = url;
-            this._openEventListeners.forEach(l => l(event));
-            return this.subscribe(chia_agent_service);
+            this._openEventListeners.forEach((l) => l(event));
+            return this.subscribe(this._serviceName);
         });
     }
     onError(error) {
-        (0, logger_1.getLogger)().error(`ws connection error: ${error.message}`);
-        this._errorEventListeners.forEach(l => l(error));
+        (0, logger_1.getLogger)().error(`ws connection error: ${error.type} ${error.target} ${error.error} ${error.message}`);
+        this._errorEventListeners.forEach((l) => l(error));
     }
     onMessage(event) {
         let payload;
@@ -271,46 +383,62 @@ class Daemon {
             ({ request_id, origin, command } = payload);
         }
         catch (err) {
-            (0, logger_1.getLogger)().error(`Failed to parse message data: ${JSON.stringify(err)}`);
-            (0, logger_1.getLogger)().error(`payload: ${event.data}`);
+            (0, logger_1.getLogger)().error(`Failed to parse ws message data: ${JSON.stringify(err)}`);
+            (0, logger_1.getLogger)().error(`ws payload: ${event.data}`);
             return;
         }
-        (0, logger_1.getLogger)().debug(`Arrived message. origin=${origin} command=${command} reqId=${request_id}`);
-        const resolver = this._responseQueue[request_id];
-        if (resolver) {
+        const entry = this._responseQueue[request_id];
+        if (entry) {
+            clearTimeout(entry.timeout);
             delete this._responseQueue[request_id];
-            resolver(payload);
+            (0, logger_1.getLogger)().debug(`Ws response received. origin=${origin} command=${command} reqId=${request_id}`);
+            entry.resolver(payload);
         }
-        this._messageEventListeners.forEach(l => l(event));
+        else {
+            (0, logger_1.getLogger)().debug(`Ws message arrived. origin=${origin} command=${command} reqId=${request_id}`);
+        }
+        (0, logger_1.getLogger)().trace(`Ws message: ${JSON.stringify(payload)}`);
+        this._messageEventListeners.forEach((l) => l(event));
         for (const o in this._messageListeners) {
             if (!Object.prototype.hasOwnProperty.call(this._messageListeners, o)) {
                 continue;
             }
             const listeners = this._messageListeners[o];
             if (origin === o || o === "all") {
-                listeners.forEach(l => l(payload));
+                listeners.forEach((l) => l(payload));
             }
         }
     }
     onClose(event) {
+        const previousSubscriptions = [...this._subscriptions];
         if (this._socket) {
-            this._socket.removeEventListener("error", this.onError);
+            this._socket.off("error", this.onError);
             this._socket.removeEventListener("message", this.onMessage);
-            this._socket.removeEventListener("close", this.onClose);
-            this._socket.removeListener("ping", this.onPing);
-            this._socket.removeListener("pong", this.onPong);
+            this._socket.off("close", this.onClose);
+            this._socket.off("ping", this.onPing);
+            this._socket.off("pong", this.onPong);
             this._socket = null;
         }
         this._closing = false;
         this._connectedUrl = "";
         this._subscriptions = [];
-        this._closeEventListeners.forEach(l => l(event));
-        this.clearAllEventListeners();
-        (0, logger_1.getLogger)().info("Closed ws connection");
+        this._closeEventListeners.forEach((l) => l(event));
+        // Don't clear event listeners - preserve them for reconnection
+        // this.clearAllEventListeners();
+        (0, logger_1.getLogger)().info(`Closed ws connection. code:${event.code} wasClean:${event.wasClean} reason:${event.reason}`);
         if (this._onClosePromise) {
             this._onClosePromise();
             this._onClosePromise = undefined;
         }
+        // Attempt reconnection if enabled and not manually closed
+        if (this._autoReconnect &&
+            this._lastConnectionUrl &&
+            !this._isReconnecting &&
+            event.code !== 1000 // 1000 = normal closure
+        ) {
+            this._isReconnecting = true;
+            this._attemptReconnection(previousSubscriptions);
+        }
     }
     onPing() {
         (0, logger_1.getLogger)().debug("Received ping");
@@ -318,4 +446,63 @@ class Daemon {
     onPong() {
         (0, logger_1.getLogger)().debug("Received pong");
     }
+    _attemptReconnection(previousSubscriptions) {
+        if (this._reconnectAttempts >= this._retryOptions.maxAttempts) {
+            (0, logger_1.getLogger)().error(`Max reconnection attempts (${this._retryOptions.maxAttempts}) reached. Giving up.`);
+            this._isReconnecting = false;
+            this._reconnectAttempts = 0;
+            // Emit a custom event for max retries reached
+            const errorEvent = {
+                type: "error",
+                message: "Max reconnection attempts reached",
+                error: new Error("Max reconnection attempts reached"),
+                target: this._socket,
+            };
+            this._errorEventListeners.forEach((l) => l(errorEvent));
+            return;
+        }
+        const delay = Math.min(this._retryOptions.initialDelay *
+            Math.pow(this._retryOptions.backoffMultiplier, this._reconnectAttempts), this._retryOptions.maxDelay);
+        this._reconnectAttempts++;
+        (0, logger_1.getLogger)().info(`Attempting reconnection ${this._reconnectAttempts}/${this._retryOptions.maxAttempts} in ${delay}ms...`);
+        this._reconnectTimer = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            this._reconnectTimer = null;
+            try {
+                const connected = yield this.connect(this._lastConnectionUrl, {
+                    timeoutMs: this._timeoutMs,
+                    autoReconnect: this._autoReconnect,
+                    retryOptions: this._retryOptions,
+                });
+                if (connected) {
+                    (0, logger_1.getLogger)().info("Reconnection successful");
+                    this._reconnectAttempts = 0;
+                    this._isReconnecting = false;
+                    // Re-establish previous subscriptions
+                    for (const service of previousSubscriptions) {
+                        try {
+                            yield this.subscribe(service);
+                            (0, logger_1.getLogger)().debug(`Re-subscribed to ${service}`);
+                        }
+                        catch (e) {
+                            (0, logger_1.getLogger)().error(`Failed to re-subscribe to ${service}: ${e}`);
+                        }
+                    }
+                    // Emit successful reconnection event
+                    const reconnectedEvent = {
+                        type: "reconnected",
+                        target: this._socket,
+                    };
+                    this._openEventListeners.forEach((l) => l(reconnectedEvent));
+                }
+                else {
+                    // Connection failed, try again
+                    this._attemptReconnection(previousSubscriptions);
+                }
+            }
+            catch (error) {
+                (0, logger_1.getLogger)().error(`Reconnection attempt failed: ${error}`);
+                this._attemptReconnection(previousSubscriptions);
+            }
+        }), delay);
+    }
 }

package/logger.d.ts

@@ -1,22 +1,49 @@
-export type TLogLevel = "error" | "warning" | "info" | "debug" | "none";
-export type TDestination = "console";
-export type Writer = {
-    write: (message: string) => void;
-};
-export declare function getLogLevel(): TLogLevel;
-export declare function setLogLevel(logLevel: TLogLevel): TLogLevel;
-export declare function getLogger(writer?: TDestination): Logger;
-declare class Logger {
-    loglevel: TLogLevel;
-    protected _writer: Writer;
-    protected constructor(logLevel: TLogLevel, writer?: TDestination | Writer);
-    static getLogger(logLevel: TLogLevel, writer?: TDestination): Logger;
+export type TLogLevel = "error" | "warning" | "info" | "debug" | "trace" | "none";
+export declare function isValidLogLevel(level: string): level is TLogLevel;
+export declare function normalizeLogLevel(level: string): TLogLevel | null;
+export interface Writer {
+    write: (message: string, level?: TLogLevel) => void;
+}
+export interface LogContext {
+    timestamp: Date;
+    level: TLogLevel;
+    loggerName: string;
+    message: string;
+}
+export type LogFormatter = (context: LogContext) => string;
+export declare function setDefaultLogLevel(level: TLogLevel): void;
+export declare function getDefaultLogLevel(): TLogLevel;
+export declare function setDefaultWriter(writer: Writer): void;
+export declare function setDefaultFormatter(formatter: LogFormatter): void;
+export declare function getDefaultFormatter(): LogFormatter;
+export declare const DEFAULT_LOGGER_NAME = "default";
+export declare const defaultLogFormatter: LogFormatter;
+export declare const simpleLogFormatter: LogFormatter;
+export declare const jsonLogFormatter: LogFormatter;
+export declare function getLogger(name?: string): Logger;
+export declare function clearLoggerCache(): void;
+export declare function createConsoleWriter(): Writer;
+export declare function createNullWriter(): Writer;
+export declare class Logger {
+    private _name;
+    private _logLevel;
+    private _writer;
+    private _formatter;
+    constructor(name: string, logLevel: TLogLevel, writer: Writer, formatter?: LogFormatter);
     setLogLevel(level: TLogLevel): void;
-    shouldWrite(logLevel: TLogLevel): boolean;
-    formatMessage(level: TLogLevel, body: string): string;
+    getLogLevel(): TLogLevel;
+    setWriter(writer: Writer): void;
+    getWriter(): Writer;
+    getName(): string;
+    setFormatter(formatter: LogFormatter): void;
+    getFormatter(): LogFormatter;
+    private _shouldWrite;
+    private _formatMessage;
+    trace(msg: any): void;
     debug(msg: any): void;
     info(msg: any): void;
     warning(msg: any): void;
     error(msg: any): void;
 }
-export {};
+export declare function getLogLevel(): TLogLevel;
+export declare function setLogLevel(level: TLogLevel): void;

package/logger.js

@@ -1,23 +1,157 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLogger = exports.setLogLevel = exports.getLogLevel = void 0;
+exports.setLogLevel = exports.getLogLevel = exports.Logger = exports.createNullWriter = exports.createConsoleWriter = exports.clearLoggerCache = exports.getLogger = exports.jsonLogFormatter = exports.simpleLogFormatter = exports.defaultLogFormatter = exports.DEFAULT_LOGGER_NAME = exports.getDefaultFormatter = exports.setDefaultFormatter = exports.setDefaultWriter = exports.getDefaultLogLevel = exports.setDefaultLogLevel = exports.normalizeLogLevel = exports.isValidLogLevel = void 0;
+const LOG_LEVELS = [
+    "error",
+    "warning",
+    "info",
+    "debug",
+    "trace",
+    "none",
+];
+function isValidLogLevel(level) {
+    return LOG_LEVELS.includes(level.toLowerCase());
+}
+exports.isValidLogLevel = isValidLogLevel;
+function normalizeLogLevel(level) {
+    const normalized = level.toLowerCase();
+    if (isValidLogLevel(normalized)) {
+        return normalized;
+    }
+    return null;
+}
+exports.normalizeLogLevel = normalizeLogLevel;
 const logPriority = {
     none: 9999,
-    error: 4,
-    warning: 3,
-    info: 2,
-    debug: 1,
+    error: 5,
+    warning: 4,
+    info: 3,
+    debug: 2,
+    trace: 1,
 };
 class ConsoleWriter {
-    write(message) {
-        console.log(message);
+    write(message, level) {
+        switch (level) {
+            case "error":
+                console.error(message);
+                break;
+            case "warning":
+                console.warn(message);
+                break;
+            case "info":
+                console.info(message);
+                break;
+            case "debug":
+                console.debug(message);
+                break;
+            case "trace":
+                console.trace(message);
+                break;
+            default:
+                console.log(message);
+        }
     }
 }
-let currentLogLevel = "error";
-function getLogLevel() { return currentLogLevel; }
-exports.getLogLevel = getLogLevel;
-function setLogLevel(logLevel) { return currentLogLevel = logLevel; }
-exports.setLogLevel = setLogLevel;
+class NullWriter {
+    write(_message, _level) {
+        // Suppress all output
+    }
+}
+// Global defaults
+let defaultLogLevel = "error";
+if (process.env.LOG_LEVEL) {
+    const normalizedLevel = normalizeLogLevel(process.env.LOG_LEVEL);
+    if (normalizedLevel) {
+        defaultLogLevel = normalizedLevel;
+    }
+    else {
+        console.warn(`Invalid LOG_LEVEL environment variable: ${process.env.LOG_LEVEL}. Using default: error`);
+    }
+}
+let defaultWriter = process.env.LOG_SUPPRESS === "true" ? new NullWriter() : new ConsoleWriter();
+// Logger instance cache
+const loggerCache = new Map();
+// Configuration functions for global defaults
+function setDefaultLogLevel(level) {
+    // Normalize for JavaScript users who might pass uppercase
+    const normalized = normalizeLogLevel(level);
+    if (!normalized) {
+        throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
+    }
+    defaultLogLevel = normalized;
+}
+exports.setDefaultLogLevel = setDefaultLogLevel;
+function getDefaultLogLevel() {
+    return defaultLogLevel;
+}
+exports.getDefaultLogLevel = getDefaultLogLevel;
+function setDefaultWriter(writer) {
+    defaultWriter = writer;
+}
+exports.setDefaultWriter = setDefaultWriter;
+function setDefaultFormatter(formatter) {
+    defaultFormatter = formatter;
+}
+exports.setDefaultFormatter = setDefaultFormatter;
+function getDefaultFormatter() {
+    return defaultFormatter;
+}
+exports.getDefaultFormatter = getDefaultFormatter;
+exports.DEFAULT_LOGGER_NAME = "default";
+// Default formatter
+const defaultLogFormatter = (context) => {
+    const timestamp = context.timestamp.toISOString();
+    const levelStr = context.level.toUpperCase();
+    const nameStr = context.loggerName === exports.DEFAULT_LOGGER_NAME
+        ? ""
+        : ` [${context.loggerName}]`;
+    return `${timestamp} [${levelStr}]${nameStr} - ${context.message}`;
+};
+exports.defaultLogFormatter = defaultLogFormatter;
+// Simple formatter without timestamp
+const simpleLogFormatter = (context) => {
+    const levelStr = context.level.toUpperCase();
+    const nameStr = context.loggerName === exports.DEFAULT_LOGGER_NAME
+        ? ""
+        : `[${context.loggerName}] `;
+    return `[${levelStr}] ${nameStr}${context.message}`;
+};
+exports.simpleLogFormatter = simpleLogFormatter;
+// JSON formatter
+const jsonLogFormatter = (context) => {
+    return JSON.stringify({
+        timestamp: context.timestamp.toISOString(),
+        level: context.level,
+        logger: context.loggerName,
+        message: context.message,
+    });
+};
+exports.jsonLogFormatter = jsonLogFormatter;
+let defaultFormatter = exports.defaultLogFormatter;
+// Factory function with caching
+function getLogger(name = exports.DEFAULT_LOGGER_NAME) {
+    let logger = loggerCache.get(name);
+    if (!logger) {
+        logger = new Logger(name, defaultLogLevel, defaultWriter, defaultFormatter);
+        loggerCache.set(name, logger);
+    }
+    return logger;
+}
+exports.getLogger = getLogger;
+// Clear logger cache (useful for testing)
+function clearLoggerCache() {
+    loggerCache.clear();
+}
+exports.clearLoggerCache = clearLoggerCache;
+// Helper to create writers
+function createConsoleWriter() {
+    return new ConsoleWriter();
+}
+exports.createConsoleWriter = createConsoleWriter;
+function createNullWriter() {
+    return new NullWriter();
+}
+exports.createNullWriter = createNullWriter;
 function stringify(obj, indent) {
     if (typeof obj === "string") {
         return obj;
@@ -41,7 +175,7 @@ function stringify(obj, indent) {
         return "[Function]";
     }
     const seen = new WeakSet();
-    return JSON.stringify(obj, (k, v) => {
+    return JSON.stringify(obj, (_k, v) => {
         if (typeof v === "object" && v !== null) {
             if (seen.has(v)) {
                 return undefined;
@@ -54,60 +188,96 @@ function stringify(obj, indent) {
         return v;
     }, indent);
 }
-const loggers = {};
-function getLogger(writer) {
-    const w = writer || "console";
-    const logger = loggers[w];
-    if (logger && logger.loglevel === currentLogLevel) {
-        return logger;
-    }
-    return loggers[w] = Logger.getLogger(currentLogLevel, w);
-}
-exports.getLogger = getLogger;
 class Logger {
-    constructor(logLevel, writer) {
-        this.loglevel = "error";
-        if (writer === "console") {
-            this._writer = new ConsoleWriter();
-        }
-        else if (writer) {
-            this._writer = writer;
+    constructor(name, logLevel, writer, formatter) {
+        // Normalize for JavaScript users who might pass uppercase
+        const normalized = normalizeLogLevel(logLevel);
+        if (!normalized) {
+            throw new Error(`Invalid log level: ${logLevel}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
         }
-        else {
-            this._writer = new ConsoleWriter();
+        this._name = name;
+        this._logLevel = normalized;
+        this._writer = writer;
+        this._formatter = formatter || defaultFormatter;
+    }
+    // Allow changing log level for this specific logger
+    setLogLevel(level) {
+        // Normalize for JavaScript users who might pass uppercase
+        const normalized = normalizeLogLevel(level);
+        if (!normalized) {
+            throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
         }
-        this.loglevel = logLevel;
+        this._logLevel = normalized;
     }
-    static getLogger(logLevel, writer) {
-        return new Logger(logLevel, writer);
+    getLogLevel() {
+        return this._logLevel;
     }
-    setLogLevel(level) {
-        this.loglevel = level;
+    // Allow changing writer for this specific logger
+    setWriter(writer) {
+        this._writer = writer;
     }
-    shouldWrite(logLevel) {
-        return logPriority[this.loglevel] <= logPriority[logLevel];
+    getWriter() {
+        return this._writer;
     }
-    formatMessage(level, body) {
-        return `${(new Date()).toLocaleString()} [${level.toUpperCase()}] ${body}`;
+    getName() {
+        return this._name;
+    }
+    setFormatter(formatter) {
+        this._formatter = formatter;
+    }
+    getFormatter() {
+        return this._formatter;
+    }
+    _shouldWrite(logLevel) {
+        return logPriority[this._logLevel] <= logPriority[logLevel];
+    }
+    _formatMessage(level, body) {
+        const context = {
+            timestamp: new Date(),
+            level,
+            loggerName: this._name,
+            message: body,
+        };
+        return this._formatter(context);
+    }
+    trace(msg) {
+        if (this._shouldWrite("trace")) {
+            this._writer.write(this._formatMessage("trace", stringify(msg)), "trace");
+        }
     }
     debug(msg) {
-        if (this.shouldWrite("debug")) {
-            this._writer.write(this.formatMessage("debug", stringify(msg)));
+        if (this._shouldWrite("debug")) {
+            this._writer.write(this._formatMessage("debug", stringify(msg)), "debug");
         }
     }
     info(msg) {
-        if (this.shouldWrite("info")) {
-            this._writer.write(this.formatMessage("info", stringify(msg)));
+        if (this._shouldWrite("info")) {
+            this._writer.write(this._formatMessage("info", stringify(msg)), "info");
         }
     }
     warning(msg) {
-        if (this.shouldWrite("warning")) {
-            this._writer.write(this.formatMessage("warning", stringify(msg)));
+        if (this._shouldWrite("warning")) {
+            this._writer.write(this._formatMessage("warning", stringify(msg)), "warning");
         }
     }
     error(msg) {
-        if (this.shouldWrite("error")) {
-            this._writer.write(this.formatMessage("error", stringify(msg)));
+        if (this._shouldWrite("error")) {
+            this._writer.write(this._formatMessage("error", stringify(msg)), "error");
         }
     }
 }
+exports.Logger = Logger;
+// For backward compatibility
+function getLogLevel() {
+    return getDefaultLogLevel();
+}
+exports.getLogLevel = getLogLevel;
+function setLogLevel(level) {
+    // Normalize for JavaScript users who might pass uppercase
+    const normalized = normalizeLogLevel(level);
+    if (!normalized) {
+        throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
+    }
+    setDefaultLogLevel(normalized);
+}
+exports.setLogLevel = setLogLevel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chia-agent",
-  "version": "14.3.2",
+  "version": "14.3.4",
   "author": "ChiaMineJP <admin@chiamine.jp>",
   "description": "chia rpc/websocket client library",
   "license": "MIT",
@@ -10,6 +10,7 @@
   },
   "bugs": "https://github.com/Chia-Mine/chia-agent/issues",
   "main": "./index.js",
+  "types": "./index.d.ts",
   "bin": {
     "chia-agent": "./bin/cli.js"
   },

package/rpc/index.d.ts

@@ -61,12 +61,16 @@ export type TRPCAgentProps = {
     skip_hostname_verification?: boolean;
 } | {
     httpAgent: HttpAgent;
+    host: string;
+    port: number;
     skip_hostname_verification?: boolean;
 };
 export declare class RPCAgent implements APIAgent {
     protected _protocol: "http" | "https";
     protected _agent: HttpsAgent | HttpAgent;
     protected _skip_hostname_verification: boolean;
+    protected _host: string;
+    protected _port: number;
     constructor(props: TRPCAgentProps);
     sendMessage<M>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
     request<R>(method: string, path: string, data?: any): Promise<R>;

package/rpc/index.js

@@ -70,9 +70,15 @@ function getConf(configPath) {
 }
 exports.getConf = getConf;
 function loadCertFilesFromConfig(config) {
-    const clientCertPath = (0, index_1.resolveFromChiaRoot)([config["/daemon_ssl/private_crt"]]);
-    const clientKeyPath = (0, index_1.resolveFromChiaRoot)([config["/daemon_ssl/private_key"]]);
-    const caCertPath = (0, index_1.resolveFromChiaRoot)([config["/private_ssl_ca/crt"]]);
+    const clientCertPath = (0, index_1.resolveFromChiaRoot)([
+        config["/daemon_ssl/private_crt"],
+    ]);
+    const clientKeyPath = (0, index_1.resolveFromChiaRoot)([
+        config["/daemon_ssl/private_key"],
+    ]);
+    const caCertPath = (0, index_1.resolveFromChiaRoot)([
+        config["/private_ssl_ca/crt"],
+    ]);
     (0, logger_1.getLogger)().debug(`Loading client cert file from ${clientCertPath}`);
     (0, logger_1.getLogger)().debug(`Loading client key file from ${clientKeyPath}`);
     (0, logger_1.getLogger)().debug(`Loading ca cert file from ${caCertPath}`);
@@ -93,15 +99,31 @@ const userAgent = "chia-agent/1.0.0";
 class RPCAgent {
     constructor(props) {
         this._skip_hostname_verification = false;
+        this._host = "";
+        this._port = 0;
         if ("httpsAgent" in props) {
             this._protocol = "https";
             this._agent = props.httpsAgent;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            // Extract host/port from httpsAgent options
+            // Note: TypeScript doesn't expose options property, but it exists at runtime
+            const agent = this._agent;
+            if (agent.options && agent.options.host && agent.options.port) {
+                this._host = agent.options.host;
+                this._port = agent.options.port;
+                (0, logger_1.getLogger)().debug(`Constructing RPCAgent with httpsAgent: ${this._host}:${this._port}`);
+            }
+            else {
+                (0, logger_1.getLogger)().debug("Constructing RPCAgent with httpsAgent (host/port not available in agent options)");
+            }
         }
         else if ("httpAgent" in props) {
             this._protocol = "http";
             this._agent = props.httpAgent;
+            this._host = props.host;
+            this._port = props.port;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            (0, logger_1.getLogger)().debug(`Constructing RPCAgent with httpAgent: ${this._host}:${this._port}`);
         }
         else if ("protocol" in props) {
             this._protocol = props.protocol;
@@ -110,12 +132,17 @@ class RPCAgent {
             let clientKey;
             let caCert;
             const keepAlive = props.keepAlive !== false;
-            const keepAliveMsecs = typeof props.keepAliveMsecs === "number" && props.keepAliveMsecs > 0 ?
-                props.keepAliveMsecs : 1000;
-            const maxSockets = typeof props.maxSockets === "number" && props.maxSockets > 0 ?
-                props.maxSockets : Infinity;
-            const timeout = typeof props.timeout === "number" && props.timeout > 0 ?
-                props.timeout : undefined;
+            const keepAliveMsecs = typeof props.keepAliveMsecs === "number" && props.keepAliveMsecs > 0
+                ? props.keepAliveMsecs
+                : 1000;
+            const maxSockets = typeof props.maxSockets === "number" && props.maxSockets > 0
+                ? props.maxSockets
+                : Infinity;
+            const timeout = typeof props.timeout === "number" && props.timeout > 0
+                ? props.timeout
+                : undefined;
+            this._host = host;
+            this._port = port;
             if (props.protocol === "https") {
                 if ("configPath" in props) {
                     const config = getConf(props.configPath);
@@ -126,7 +153,11 @@ class RPCAgent {
                     this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
                 }
                 else {
-                    ({ client_cert: clientCert, client_key: clientKey, ca_cert: caCert } = props);
+                    ({
+                        client_cert: clientCert,
+                        client_key: clientKey,
+                        ca_cert: caCert,
+                    } = props);
                     this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
                 }
                 this._agent = new https_1.Agent({
@@ -141,6 +172,7 @@ class RPCAgent {
                     maxSockets,
                     timeout,
                 });
+                (0, logger_1.getLogger)().debug(`Constructed RPCAgent with httpsAgent: ${host}:${port}`);
             }
             else {
                 this._agent = new http_1.Agent({
@@ -156,12 +188,15 @@ class RPCAgent {
             let host;
             let port;
             const keepAlive = props.keepAlive !== false;
-            const keepAliveMsecs = typeof props.keepAliveMsecs === "number" && props.keepAliveMsecs > 0 ?
-                props.keepAliveMsecs : 1000;
-            const maxSockets = typeof props.maxSockets === "number" && props.maxSockets > 0 ?
-                props.maxSockets : Infinity;
-            const timeout = typeof props.timeout === "number" && props.timeout > 0 ?
-                props.timeout : undefined;
+            const keepAliveMsecs = typeof props.keepAliveMsecs === "number" && props.keepAliveMsecs > 0
+                ? props.keepAliveMsecs
+                : 1000;
+            const maxSockets = typeof props.maxSockets === "number" && props.maxSockets > 0
+                ? props.maxSockets
+                : Infinity;
+            const timeout = typeof props.timeout === "number" && props.timeout > 0
+                ? props.timeout
+                : undefined;
             const config = getConf("configPath" in props ? props.configPath : undefined);
             if (props.host && typeof props.port === "number") {
                 ({ host, port } = props);
@@ -175,6 +210,8 @@ class RPCAgent {
             const certs = loadCertFilesFromConfig(config);
             const { clientCert, clientKey, caCert } = certs;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            this._host = host;
+            this._port = port;
             this._agent = new https_1.Agent({
                 host: host,
                 port: port,
@@ -192,7 +229,7 @@ class RPCAgent {
     sendMessage(destination, command, data) {
         return __awaiter(this, void 0, void 0, function* () {
             // parameter `destination` is not used because target rpc server is determined by url.
-            (0, logger_1.getLogger)().debug(`Sending message. dest=${destination} command=${command}`);
+            (0, logger_1.getLogger)().debug(`Sending RPC message. dest=${destination} command=${command}`);
             return this.request("POST", command, data);
         });
     }
@@ -206,9 +243,8 @@ class RPCAgent {
                     Accept: "application/json, text/plain, */*",
                     "User-Agent": userAgent,
                 };
-                if ("options" in this._agent && typeof this._agent.options.host === "string") {
-                    // Assuming `this._agent instanceof HttpsAgent` is true.
-                    headers.Host = this._agent.options.host;
+                if (this._host) {
+                    headers.Host = this._host;
                 }
                 const options = {
                     path: pathname,
@@ -216,6 +252,11 @@ class RPCAgent {
                     agent: this._agent,
                     headers,
                 };
+                // For HTTP protocol, we need to explicitly set hostname and port
+                if (this._protocol === "http") {
+                    options.hostname = this._host;
+                    options.port = this._port;
+                }
                 if (this._skip_hostname_verification) {
                     options.checkServerIdentity = () => {
                         return undefined;
@@ -243,7 +284,9 @@ class RPCAgent {
                     }
                 }
                 const transporter = this._protocol === "https" ? https_1.request : http_1.request;
-                (0, logger_1.getLogger)().debug(`Requesting to ${options.protocol}//${options.hostname}:${options.port}${options.path}`);
+                (0, logger_1.getLogger)().debug(`Dispatching RPC ${METHOD} request to ${this._protocol}//${this._host}:${this._port}${options.path}`);
+                (0, logger_1.getLogger)().trace(`Request options: ${JSON.stringify(options)}`);
+                (0, logger_1.getLogger)().trace(`Request body: ${body}`);
                 const req = transporter(options, (res) => {
                     if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
                         (0, logger_1.getLogger)().error(`Status not ok: ${res.statusCode}`);
@@ -256,11 +299,12 @@ class RPCAgent {
                         return reject(new Error(`Status not ok: ${res.statusCode}`));
                     }
                     const chunks = [];
-                    res.on("data", chunk => {
+                    res.on("data", (chunk) => {
                         chunks.push(chunk);
                         if (chunks.length === 0) {
                             (0, logger_1.getLogger)().debug("The first response chunk data arrived");
                         }
+                        (0, logger_1.getLogger)().trace(`Response chunk #${chunks.length} - ${chunk.length} bytes: ${chunk.toString()}`);
                     });
                     res.on("end", () => {
                         try {
@@ -280,6 +324,8 @@ class RPCAgent {
                                     (0, logger_1.getLogger)().info(`API failure: ${d.error}`);
                                     return reject(d);
                                 }
+                                (0, logger_1.getLogger)().debug(`RPC response received from ${this._protocol}//${this._host}:${this._port}${options.path}`);
+                                (0, logger_1.getLogger)().trace(`RPC response data: ${JSON.stringify(d)}`);
                                 return resolve(d);
                             }
                             // RPC Server should return response like
@@ -289,20 +335,23 @@ class RPCAgent {
                             reject(new Error("Server responded without expected data"));
                         }
                         catch (e) {
-                            (0, logger_1.getLogger)().error("Failed to parse response data");
+                            (0, logger_1.getLogger)().error(`Failed to parse response data: ${JSON.stringify(e)}`);
                             try {
                                 (0, logger_1.getLogger)().error(Buffer.concat(chunks).toString());
                             }
-                            catch (_) { /* Do nothing */ }
+                            catch (_e2) {
+                                /* Do nothing */
+                            }
                             reject(new Error("Server responded without expected data"));
                         }
                     });
                 });
-                req.on("error", error => {
+                req.on("error", (error) => {
                     (0, logger_1.getLogger)().error(JSON.stringify(error));
                     reject(error);
                 });
-                if ((METHOD === "POST" || METHOD === "PUT" || METHOD === "DELETE") && body) {
+                if ((METHOD === "POST" || METHOD === "PUT" || METHOD === "DELETE") &&
+                    body) {
                     req.write(body);
                 }
                 req.end();