chia-agent 14.0.0-beta.0 → 14.0.0-beta.2

package/CHANGELOG.md

@@ -3,6 +3,60 @@
 ## [14.0.0]
 ### Breaking change
 - When RPC API responds with `success: false`, its `Promise` now does `reject`. (Previously it does `resolve`)
+### Changed
+- Loosened a type of `agent` to call RPC APIs. RPC APIs can be invoked with `agent` which just implements
+  `sendMessage` method depicted as below.
+```typescript
+export interface APIAgent {
+  sendMessage<M extends unknown>(
+          destination: string,
+          command: string,
+          data?: Record<string, unknown>,
+  ): Promise<M>;
+}
+```
+### Added
+- Added connectivity options for `RPCAgent`.
+  - `keepAlive` (default: `true`)
+  - `keepAliveMsecs` (default: `1000`)
+  - `maxSockets` (default: `Infinity`)
+  - `timeout` (default: `undefined`)
+```typescript
+// Usage
+const {RPCAgent} = require("chia-agent");
+const {get_plots} = require("chia-agent/api/rpc");
+
+const agent = new RPCAgent({
+  service: "harvester",
+  keepAlive: true,
+  keepAliveMsecs: 3000,
+  maxSockets: 1, // Avoid to set `1` if your requests may be sent in parallel.
+  timeout: 5000,
+});
+const res = await get_plots(agent);
+```
+- Added `httpsAgent`, `httpAgent` option for `RPCAgent`.
+  You can now configure and inject your own `require('https').Agent` into `RPCAgent`.
+```typescript
+// Usage
+const {Agent: HttpsAgent} = require("https"); // or const {Agent: HttpAgent} = require('http');
+const {RPCAgent} = require("chia-agent");
+const {get_plots} = require("chia-agent/api/rpc");
+
+const httpsAgent = new HttpsAgent({
+  host: "localhost",
+  port: 8560,
+  ca: ...,
+  cert: ...,
+  key: ...,
+  rejectUnauthorized: false,
+});
+const agent = new RPCAgent({httpsAgent: httpsAgent}); // `new RPCAgent({httpAgent: httpAgent});` is also allowed.
+const res = await get_plots(agent);
+```
+
+### Fixed
+- Fixed an issue where some of the RPC Pool APIs did not handle request parameters correctly.
 
 ## [13.2.0]
 ### Added

package/agent/index.d.ts

@@ -0,0 +1,3 @@
+export interface APIAgent {
+    sendMessage<M extends unknown>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
+}

package/agent/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/api/rpc/pool/index.d.ts

@@ -1,25 +1,25 @@
 import { str, uint64 } from "../../chia/types/_python_types_";
-import { TRPCAgent } from "../../../rpc";
+import type { RPCAgent } from "../../../rpc";
 import { ErrorResponse, GetFarmerResponse, GetPoolInfoResponse, PostFarmerRequest, PostFarmerResponse, PostPartialRequest, PostPartialResponse, PutFarmerRequest, PutFarmerResponse } from "../../chia/protocols/pool_protocol";
 import { FarmerRecord } from "../../chia/pool/store";
 export declare type TPoolInfoResponse = GetPoolInfoResponse;
-export declare function pool_info(agent: TRPCAgent): Promise<GetPoolInfoResponse>;
+export declare function pool_info(agent: RPCAgent): Promise<GetPoolInfoResponse>;
 export declare type TGetFarmerRequest = {
     launcher_id: str;
     authentication_token: str;
     signature: str;
 };
 export declare type TGetFarmerResponse = GetFarmerResponse;
-export declare function get_farmer(agent: TRPCAgent, data: TGetFarmerRequest): Promise<GetFarmerResponse>;
+export declare function get_farmer(agent: RPCAgent, data: TGetFarmerRequest): Promise<GetFarmerResponse>;
 export declare type TPostFarmerRequest = PostFarmerRequest;
 export declare type TPostFarmerResponse = PostFarmerResponse | ErrorResponse;
-export declare function post_farmer(agent: TRPCAgent, data: TPostFarmerRequest): Promise<TPostFarmerResponse>;
+export declare function post_farmer(agent: RPCAgent, data: TPostFarmerRequest): Promise<TPostFarmerResponse>;
 export declare type TPutFarmerRequest = PutFarmerRequest;
 export declare type TPutFarmerResponse = PutFarmerResponse | ErrorResponse;
-export declare function put_farmer(agent: TRPCAgent, data: TPutFarmerRequest): Promise<TPutFarmerResponse>;
+export declare function put_farmer(agent: RPCAgent, data: TPutFarmerRequest): Promise<TPutFarmerResponse>;
 export declare type TPartialRequest = PostPartialRequest;
 export declare type TPartialResponse = PostPartialResponse | ErrorResponse;
-export declare function partial(agent: TRPCAgent, data: TPartialRequest): Promise<TPartialResponse>;
+export declare function partial(agent: RPCAgent, data: TPartialRequest): Promise<TPartialResponse>;
 export declare type TLoginRequest = {
     launcher_id: str;
     authentication_token: uint64;
@@ -29,4 +29,4 @@ export declare type TLoginResponse = {
     farmer_record: FarmerRecord;
     recent_partials: Array<[uint64, uint64]>;
 } | {};
-export declare function login(agent: TRPCAgent, data: TLoginRequest): Promise<TLoginResponse>;
+export declare function login(agent: RPCAgent, data: TLoginRequest): Promise<TLoginResponse>;

package/api/rpc/pool/index.js

@@ -18,19 +18,19 @@ function pool_info(agent) {
 exports.pool_info = pool_info;
 function get_farmer(agent, data) {
     return __awaiter(this, void 0, void 0, function* () {
-        return agent.request("GET", "farmer");
+        return agent.request("GET", "farmer", data);
     });
 }
 exports.get_farmer = get_farmer;
 function post_farmer(agent, data) {
     return __awaiter(this, void 0, void 0, function* () {
-        return agent.request("POST", "farmer");
+        return agent.request("POST", "farmer", data);
     });
 }
 exports.post_farmer = post_farmer;
 function put_farmer(agent, data) {
     return __awaiter(this, void 0, void 0, function* () {
-        return agent.request("PUT", "farmer");
+        return agent.request("PUT", "farmer", data);
     });
 }
 exports.put_farmer = put_farmer;

package/api/types.d.ts

@@ -11,7 +11,7 @@ export declare type GetMessageType<O extends string, C extends string, D> = {
     request_id: string;
     destination: string;
 };
-export declare type ResType<T extends TRPCAgent | TDaemon, A, D> = T extends TRPCAgent ? A : D;
+export declare type ResType<T extends TRPCAgent | TDaemon, A, D> = T extends TDaemon ? D : A;
 export declare const wallet_ui_service = "wallet_ui";
 export declare const metrics_service = "metrics";
 export declare type TConnectionGeneral = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chia-agent",
-  "version": "14.0.0-beta.0",
+  "version": "14.0.0-beta.2",
   "author": "ChiaMineJP <admin@chiamine.jp>",
   "description": "chia rpc/websocket client library",
   "license": "MIT",

package/rpc/index.d.ts

@@ -2,11 +2,18 @@
 import { Agent as HttpsAgent } from "https";
 import { Agent as HttpAgent } from "http";
 import { TConfig } from "../config/index";
+import { APIAgent } from "../agent/index";
 declare type TDestination = "farmer" | "harvester" | "full_node" | "wallet" | "data_layer" | "daemon" | "pool";
 export declare function getConnectionInfoFromConfig(destination: TDestination, config: TConfig): {
     hostname: string;
     port: number;
 };
+export declare function getConf(configPath?: string): TConfig;
+export declare function loadCertFilesFromConfig(config: TConfig): {
+    clientCert: Buffer;
+    clientKey: Buffer;
+    caCert: Buffer;
+};
 export declare type TRPCAgentProps = {
     protocol: "https";
     host: string;
@@ -15,41 +22,52 @@ export declare type TRPCAgentProps = {
     client_cert?: string | Buffer;
     client_key?: string | Buffer;
     skip_hostname_verification?: boolean;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    timeout?: number;
 } | {
     protocol: "https";
     host: string;
     port: number;
     configPath: string;
     skip_hostname_verification?: boolean;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    timeout?: number;
 } | {
     protocol: "http";
     host: string;
     port: number;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    timeout?: number;
 } | {
     service: TDestination;
     host?: string;
     port?: number;
     configPath?: string;
     skip_hostname_verification?: boolean;
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    timeout?: number;
+} | {
+    httpsAgent: HttpsAgent;
+    skip_hostname_verification?: boolean;
+} | {
+    httpAgent: HttpAgent;
+    skip_hostname_verification?: boolean;
 };
-export declare class RPCAgent {
+export declare class RPCAgent implements APIAgent {
     protected _protocol: "http" | "https";
-    protected _hostname: string;
-    protected _port: number;
-    protected _caCert?: string | Buffer;
-    protected _clientCert?: string | Buffer;
-    protected _clientKey?: string | Buffer;
     protected _agent: HttpsAgent | HttpAgent;
     protected _skip_hostname_verification: boolean;
     constructor(props: TRPCAgentProps);
-    protected _getConfig(configPath?: string): TConfig;
-    protected _loadCertFilesFromConfig(config: TConfig): {
-        clientCert: Buffer;
-        clientKey: Buffer;
-        caCert: Buffer;
-    };
     sendMessage<M extends unknown>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
     request<R>(method: string, path: string, data?: any): Promise<R>;
 }
-export declare type TRPCAgent = InstanceType<typeof RPCAgent>;
+export declare type TRPCAgent = APIAgent;
 export {};

package/rpc/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPCAgent = exports.getConnectionInfoFromConfig = void 0;
+exports.RPCAgent = exports.loadCertFilesFromConfig = exports.getConf = exports.getConnectionInfoFromConfig = void 0;
 const https_1 = require("https");
 const http_1 = require("http");
 const fs_1 = require("fs");
@@ -60,100 +60,135 @@ function getConnectionInfoFromConfig(destination, config) {
     return { hostname, port };
 }
 exports.getConnectionInfoFromConfig = getConnectionInfoFromConfig;
+function getConf(configPath) {
+    configPath = configPath || index_1.configPath;
+    if (!fs_1.existsSync(configPath)) {
+        logger_1.getLogger().error(`chia config file does not exist at: ${configPath}`);
+        throw new Error("chia config file Not Found.");
+    }
+    return index_1.getConfig(configPath);
+}
+exports.getConf = getConf;
+function loadCertFilesFromConfig(config) {
+    const clientCertPath = index_1.resolveFromChiaRoot([config["/daemon_ssl/private_crt"]]);
+    const clientKeyPath = index_1.resolveFromChiaRoot([config["/daemon_ssl/private_key"]]);
+    const caCertPath = index_1.resolveFromChiaRoot([config["/private_ssl_ca/crt"]]);
+    logger_1.getLogger().debug(`Loading client cert file from ${clientCertPath}`);
+    logger_1.getLogger().debug(`Loading client key file from ${clientKeyPath}`);
+    logger_1.getLogger().debug(`Loading ca cert file from ${caCertPath}`);
+    const getCertOrKey = (path) => {
+        if (!fs_1.existsSync(path)) {
+            logger_1.getLogger().error(`ssl crt/key does not exist at: ${path}`);
+            throw new Error(`crt/key Not Found at ${path}`);
+        }
+        return fs_1.readFileSync(path);
+    };
+    const clientCert = getCertOrKey(clientCertPath);
+    const clientKey = getCertOrKey(clientKeyPath);
+    const caCert = getCertOrKey(caCertPath);
+    return { clientCert, clientKey, caCert };
+}
+exports.loadCertFilesFromConfig = loadCertFilesFromConfig;
 const userAgent = "chia-agent/1.0.0";
 class RPCAgent {
     constructor(props) {
-        this._caCert = "";
-        this._clientCert = "";
-        this._clientKey = "";
         this._skip_hostname_verification = false;
-        if ("protocol" in props) {
+        if ("httpsAgent" in props) {
+            this._protocol = "https";
+            this._agent = props.httpsAgent;
+            this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+        }
+        else if ("httpAgent" in props) {
+            this._protocol = "http";
+            this._agent = props.httpAgent;
+            this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+        }
+        else if ("protocol" in props) {
             this._protocol = props.protocol;
-            this._hostname = props.host;
-            this._port = props.port;
+            const { host, port } = props;
+            let clientCert;
+            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;
             if (props.protocol === "https") {
                 if ("configPath" in props) {
-                    const config = this._getConfig(props.configPath);
-                    const certs = this._loadCertFilesFromConfig(config);
-                    this._clientCert = certs.clientCert;
-                    this._clientKey = certs.clientKey;
-                    this._caCert = certs.caCert;
+                    const config = getConf(props.configPath);
+                    const certs = loadCertFilesFromConfig(config);
+                    clientCert = certs.clientCert;
+                    clientKey = certs.clientKey;
+                    caCert = certs.caCert;
                     this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
                 }
                 else {
-                    this._caCert = props.ca_cert;
-                    this._clientCert = props.client_cert;
-                    this._clientKey = props.client_key;
+                    ({ 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({
-                    host: this._hostname,
-                    port: this._port,
-                    ca: this._caCert,
-                    cert: this._clientCert,
-                    key: this._clientKey,
-                    rejectUnauthorized: Boolean(this._caCert) && this._hostname !== "localhost",
+                    host,
+                    port,
+                    ca: caCert,
+                    cert: clientCert,
+                    key: clientKey,
+                    rejectUnauthorized: Boolean(caCert) && host !== "localhost",
+                    keepAlive,
+                    keepAliveMsecs,
+                    maxSockets,
+                    timeout,
                 });
             }
             else {
-                this._agent = new http_1.Agent();
+                this._agent = new http_1.Agent({
+                    keepAlive,
+                    keepAliveMsecs,
+                    maxSockets,
+                    timeout,
+                });
             }
         }
         else {
             this._protocol = "https";
-            const config = this._getConfig("configPath" in props ? props.configPath : undefined);
+            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 config = getConf("configPath" in props ? props.configPath : undefined);
             if (props.host && typeof props.port === "number") {
-                this._hostname = props.host;
-                this._port = props.port;
+                ({ host, port } = props);
             }
             else {
-                const { hostname, port } = getConnectionInfoFromConfig(props.service, config);
-                this._hostname = props.host ? props.host : hostname;
-                this._port = typeof props.port === "number" ? props.port : port;
+                const info = getConnectionInfoFromConfig(props.service, config);
+                host = props.host ? props.host : info.hostname;
+                port = typeof props.port === "number" ? props.port : info.port;
             }
-            logger_1.getLogger().debug(`Picked ${this._hostname}:${this._port} for ${props.service}`);
-            const certs = this._loadCertFilesFromConfig(config);
-            this._clientCert = certs.clientCert;
-            this._clientKey = certs.clientKey;
-            this._caCert = certs.caCert;
+            logger_1.getLogger().debug(`Picked ${host}:${port} for ${props.service}`);
+            const certs = loadCertFilesFromConfig(config);
+            const { clientCert, clientKey, caCert } = certs;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
             this._agent = new https_1.Agent({
-                host: this._hostname,
-                port: this._port,
-                ca: this._caCert,
-                cert: this._clientCert,
-                key: this._clientKey,
-                rejectUnauthorized: Boolean(this._caCert) && this._hostname !== "localhost",
+                host: host,
+                port: port,
+                ca: caCert,
+                cert: clientCert,
+                key: clientKey,
+                rejectUnauthorized: Boolean(caCert) && host !== "localhost",
+                keepAlive,
+                keepAliveMsecs,
+                maxSockets,
+                timeout,
             });
         }
     }
-    _getConfig(configPath) {
-        configPath = configPath || index_1.configPath;
-        if (!fs_1.existsSync(configPath)) {
-            logger_1.getLogger().error(`chia config file does not exist at: ${configPath}`);
-            throw new Error("chia config file Not Found.");
-        }
-        return index_1.getConfig(configPath);
-    }
-    _loadCertFilesFromConfig(config) {
-        const clientCertPath = index_1.resolveFromChiaRoot([config["/daemon_ssl/private_crt"]]);
-        const clientKeyPath = index_1.resolveFromChiaRoot([config["/daemon_ssl/private_key"]]);
-        const caCertPath = index_1.resolveFromChiaRoot([config["/private_ssl_ca/crt"]]);
-        logger_1.getLogger().debug(`Loading client cert file from ${clientCertPath}`);
-        logger_1.getLogger().debug(`Loading client key file from ${clientKeyPath}`);
-        logger_1.getLogger().debug(`Loading ca cert file from ${caCertPath}`);
-        const getCertOrKey = (path) => {
-            if (!fs_1.existsSync(path)) {
-                logger_1.getLogger().error(`ssl crt/key does not exist at: ${path}`);
-                throw new Error(`crt/key Not Found at ${path}`);
-            }
-            return fs_1.readFileSync(path);
-        };
-        const clientCert = getCertOrKey(clientCertPath);
-        const clientKey = getCertOrKey(clientKeyPath);
-        const caCert = getCertOrKey(caCertPath);
-        return { clientCert, clientKey, caCert };
-    }
     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.
@@ -168,9 +203,6 @@ class RPCAgent {
                 const pathname = `/${path.replace(/^\/+/, "")}`;
                 const METHOD = method.toUpperCase();
                 const options = {
-                    protocol: this._protocol + ":",
-                    hostname: this._hostname,
-                    port: `${this._port}`,
                     path: pathname,
                     method: METHOD,
                     agent: this._agent,