@hiero-ledger/sdk 2.70.0

package/src/channel/NativeChannel.js

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+import Channel, { encodeRequest, decodeUnaryResponse } from "./Channel.js";
+import * as base64 from "../encoding/base64.native.js";
+import HttpError from "../http/HttpError.js";
+import HttpStatus from "../http/HttpStatus.js";
+import { SDK_NAME, SDK_VERSION } from "../version.js";
+
+export default class NativeChannel extends Channel {
+    /**
+     * @param {string} address
+     */
+    constructor(address) {
+        super();
+
+        /**
+         * @type {string}
+         * @private
+         */
+        this._address = address;
+    }
+
+    /**
+     * @override
+     * @returns {void}
+     */
+    close() {
+        // do nothing
+    }
+
+    /**
+     * @override
+     * @protected
+     * @param {string} serviceName
+     * @returns {import("protobufjs").RPCImpl}
+     */
+    _createUnaryClient(serviceName) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        return async (method, requestData, callback) => {
+            try {
+                const data = base64.encode(
+                    new Uint8Array(encodeRequest(requestData)),
+                );
+
+                // this will be executed in react native environment sho
+                // fetch should be available
+                //eslint-disable-next-line n/no-unsupported-features/node-builtins
+                const response = await fetch(
+                    `${this._address}/proto.${serviceName}/${method.name}`,
+                    {
+                        method: "POST",
+                        headers: {
+                            "content-type": "application/grpc-web-text",
+                            "x-user-agent": `${SDK_NAME}/${SDK_VERSION}`,
+                            "x-accept-content-transfer-encoding": "base64",
+                            "x-grpc-web": "1",
+                        },
+                        body: data,
+                    },
+                );
+
+                if (!response.ok) {
+                    const error = new HttpError(
+                        HttpStatus._fromValue(response.status),
+                    );
+                    callback(error, null);
+                }
+
+                const blob = await response.blob();
+
+                /** @type {string} */
+                const responseData = await new Promise((resolve, reject) => {
+                    const reader = new FileReader();
+                    reader.readAsDataURL(blob);
+                    reader.onloadend = () => {
+                        resolve(/** @type {string} */ (reader.result));
+                    };
+                    reader.onerror = reject;
+                });
+
+                let responseBuffer;
+                if (
+                    responseData.startsWith(
+                        "data:application/octet-stream;base64,",
+                    )
+                ) {
+                    responseBuffer = base64.decode(
+                        responseData.split(
+                            "data:application/octet-stream;base64,",
+                        )[1],
+                    );
+                } else if (
+                    responseData.startsWith(
+                        "data:application/grpc-web+proto;base64,",
+                    )
+                ) {
+                    responseBuffer = base64.decode(
+                        responseData.split(
+                            "data:application/grpc-web+proto;base64,",
+                        )[1],
+                    );
+                } else {
+                    throw new Error(
+                        `Expected response data to be base64 encode with a 'data:application/octet-stream;base64,' or 'data:application/grpc-web+proto;base64,' prefix, but found: ${responseData}`,
+                    );
+                }
+
+                const unaryResponse = decodeUnaryResponse(
+                    // @ts-ignore
+                    responseBuffer.buffer,
+                    responseBuffer.byteOffset,
+                    responseBuffer.byteLength,
+                );
+
+                callback(null, unaryResponse);
+            } catch (error) {
+                callback(/** @type {Error} */ (error), null);
+            }
+        };
+    }
+}

package/src/channel/NodeChannel.js

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: Apache-2.0
+import tls from "tls";
+import { Client, credentials, Metadata } from "@grpc/grpc-js";
+import Channel from "./Channel.js";
+import GrpcServicesError from "../grpc/GrpcServiceError.js";
+import GrpcStatus from "../grpc/GrpcStatus.js";
+import { ALL_NETWORK_IPS } from "../constants/ClientConstants.js";
+import { SDK_NAME, SDK_VERSION } from "../version.js";
+
+/** @type {{ [key: string]: Client }} */
+const clientCache = {};
+
+export default class NodeChannel extends Channel {
+    /**
+     * @internal
+     * @param {string} address
+     * @param {number=} maxExecutionTime
+     */
+    constructor(address, maxExecutionTime) {
+        super();
+
+        /** @type {Client | null} */
+        this._client = null;
+
+        this.address = address;
+        this.maxExecutionTime = maxExecutionTime;
+
+        const { ip, port } = this.parseAddress(address);
+        this.nodeIp = ip;
+        this.nodePort = port;
+    }
+
+    /**
+     * Convert certificate bytes to PEM format
+     * @param {Buffer} certBytes
+     * @returns {string}
+     */
+    bytesToPem(certBytes) {
+        const base64Cert = certBytes.toString("base64");
+        const lines = base64Cert.match(/.{1,64}/g)?.join("\n") || "";
+        return `-----BEGIN CERTIFICATE-----\n${lines}\n-----END CERTIFICATE-----`;
+    }
+
+    /**
+     * Validates and parses an address in the "IP:Port" format.
+     * @param {string} address
+     * @returns {{ ip: string, port: string }}
+     */
+    parseAddress(address) {
+        const [ip, port] = address.split(":");
+        if (!ip || !port) {
+            throw new Error(
+                "Invalid address format. Expected format: 'IP:Port'",
+            );
+        }
+        return { ip, port };
+    }
+
+    /**
+     * Retrieve the server's certificate dynamically.
+     * @returns {Promise<string>}
+     */
+    async _retrieveCertificate() {
+        return new Promise((resolve, reject) => {
+            const socket = tls.connect(
+                {
+                    host: this.nodeIp,
+                    port: Number(this.nodePort),
+                    rejectUnauthorized: false,
+                },
+                () => {
+                    try {
+                        const cert = socket.getPeerCertificate();
+
+                        if (cert && cert.raw) {
+                            resolve(this.bytesToPem(cert.raw));
+                        } else {
+                            reject(new Error("No certificate retrieved."));
+                        }
+                    } catch (err) {
+                        reject(err);
+                    } finally {
+                        socket.end();
+                    }
+                },
+            );
+
+            socket.on("error", reject);
+        });
+    }
+
+    /**
+     * Initialize the gRPC client
+     * @returns {Promise<void>}
+     */
+    async _initializeClient() {
+        if (clientCache[this.address]) {
+            this._client = clientCache[this.address];
+            return;
+        }
+
+        let security;
+        const options = {
+            "grpc.ssl_target_name_override": "127.0.0.1",
+            "grpc.default_authority": "127.0.0.1",
+            "grpc.http_connect_creds": "0",
+            "grpc.keepalive_time_ms": 100000,
+            "grpc.keepalive_timeout_ms": 10000,
+            "grpc.keepalive_permit_without_calls": 1,
+            "grpc.enable_retries": 1,
+        };
+
+        // If the port is 50212, use TLS
+        if (this.nodePort === "50212") {
+            const certificate = Buffer.from(await this._retrieveCertificate());
+
+            security = credentials.createSsl(certificate);
+        } else {
+            security = credentials.createInsecure();
+        }
+
+        this._client = new Client(this.address, security, options);
+
+        clientCache[this.address] = this._client;
+    }
+
+    /**
+     * @override
+     * @returns {void}
+     */
+    close() {
+        if (this._client) {
+            this._client.close();
+            delete clientCache[this.address];
+        }
+    }
+
+    /**
+     * @override
+     * @protected
+     * @param {string} serviceName
+     * @returns {import("protobufjs").RPCImpl}
+     */
+    _createUnaryClient(serviceName) {
+        return (method, requestData, callback) => {
+            this._initializeClient()
+                .then(() => {
+                    const deadline = new Date();
+                    const milliseconds = this.maxExecutionTime
+                        ? this.maxExecutionTime
+                        : 10000;
+                    deadline.setMilliseconds(
+                        deadline.getMilliseconds() + milliseconds,
+                    );
+
+                    this._client?.waitForReady(deadline, (err) => {
+                        if (err) {
+                            callback(
+                                new GrpcServicesError(
+                                    GrpcStatus.Timeout,
+                                    // Added colons to the IP address to resolve a SonarCloud IP issue.
+                                    ALL_NETWORK_IPS[`${this.nodeIp}:`],
+                                ),
+                            );
+                        } else {
+                            // Create metadata with user agent
+                            const metadata = new Metadata();
+
+                            metadata.set(
+                                "x-user-agent",
+                                `${SDK_NAME}/${SDK_VERSION}`,
+                            );
+
+                            this._client?.makeUnaryRequest(
+                                `/proto.${serviceName}/${method.name}`,
+                                (value) => value,
+                                (value) => value,
+                                Buffer.from(requestData),
+                                metadata,
+                                (e, r) => {
+                                    callback(e, r);
+                                },
+                            );
+                        }
+                    });
+                })
+                .catch((err) => {
+                    if (err instanceof Error) {
+                        callback(err);
+                    } else {
+                        callback(new Error("An unexpected error occurred"));
+                    }
+                });
+        };
+    }
+}

package/src/channel/NodeMirrorChannel.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import * as grpc from "@grpc/grpc-js";
+import MirrorChannel from "./MirrorChannel.js";
+
+/**
+ * @typedef {import("../channel/Channel.js").default} Channel
+ * @typedef {import("./MirrorChannel.js").MirrorError} MirrorError
+ */
+
+/**
+ * @internal
+ */
+export default class NodeMirrorChannel extends MirrorChannel {
+    /**
+     * @internal
+     * @param {string} address
+     */
+    constructor(address) {
+        super();
+
+        /**
+         * @type {grpc.Client}
+         * @private
+         */
+        this._client = new grpc.Client(
+            address,
+            address.endsWith(":50212") || address.endsWith(":443")
+                ? grpc.credentials.createSsl()
+                : grpc.credentials.createInsecure(),
+            {
+                "grpc.keepalive_time_ms": 90000,
+                "grpc.keepalive_timeout_ms": 5000,
+            },
+        );
+    }
+
+    /**
+     * @override
+     * @returns {void}
+     */
+    close() {
+        this._client.close();
+    }
+
+    /**
+     * @override
+     * @internal
+     * @param {string} serviceName
+     * @param {string} methodName
+     * @param {Uint8Array} requestData
+     * @param {(data: Uint8Array) => void} callback
+     * @param {(error: MirrorError | Error) => void} error
+     * @param {() => void} end
+     * @returns {() => void}
+     */
+    makeServerStreamRequest(
+        serviceName,
+        methodName,
+        requestData,
+        callback,
+        error,
+        end,
+    ) {
+        const stream = this._client
+            .makeServerStreamRequest(
+                `/com.hedera.mirror.api.proto.${serviceName}/${methodName}`,
+                (value) => value,
+                (value) => value,
+                Buffer.from(requestData),
+            )
+            .on("data", (/** @type {Uint8Array} */ data) => {
+                callback(data);
+            })
+            .on("status", (/** @type {grpc.StatusObject} */ status) => {
+                if (status.code == 0) {
+                    end();
+                } else {
+                    error(status);
+                }
+            })
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            .on("error", (/** @type {grpc.StatusObject} */ err) => {
+                error(err);
+            });
+
+        return () => {
+            stream.cancel();
+        };
+    }
+}

package/src/channel/WebChannel.js

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: Apache-2.0
+import { ALL_WEB_NETWORK_NODES } from "../constants/ClientConstants.js";
+import GrpcServiceError from "../grpc/GrpcServiceError.js";
+import GrpcStatus from "../grpc/GrpcStatus.js";
+import HttpError from "../http/HttpError.js";
+import HttpStatus from "../http/HttpStatus.js";
+import { SDK_NAME, SDK_VERSION } from "../version.js";
+import Channel, { encodeRequest, decodeUnaryResponse } from "./Channel.js";
+
+export default class WebChannel extends Channel {
+    /**
+     * @param {string} address
+     */
+    constructor(address) {
+        super();
+
+        /**
+         * @type {string}
+         * @private
+         */
+        this._address = address;
+    }
+
+    /**
+     * @override
+     * @returns {void}
+     */
+    close() {
+        // do nothing
+    }
+
+    /**
+     * @override
+     * @protected
+     * @param {string} serviceName
+     * @returns {import("protobufjs").RPCImpl}
+     */
+    _createUnaryClient(serviceName) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        return async (method, requestData, callback) => {
+            try {
+                const shouldUseHttps = !(
+                    this._address.includes("localhost") ||
+                    this._address.includes("127.0.0.1")
+                );
+
+                const address = shouldUseHttps
+                    ? `https://${this._address}`
+                    : `http://${this._address}`;
+                // this will be executed in a browser environment so eslint is
+                // disabled for the fetch call
+                //eslint-disable-next-line n/no-unsupported-features/node-builtins
+                const response = await fetch(
+                    `${address}/proto.${serviceName}/${method.name}`,
+                    {
+                        method: "POST",
+                        headers: {
+                            "content-type": "application/grpc-web+proto",
+                            "x-user-agent": `${SDK_NAME}/${SDK_VERSION}`,
+                            "x-grpc-web": "1",
+                        },
+                        body: encodeRequest(requestData),
+                    },
+                );
+
+                if (!response.ok) {
+                    const error = new HttpError(
+                        HttpStatus._fromValue(response.status),
+                    );
+                    callback(error, null);
+                }
+
+                // Check headers for gRPC errors
+                const grpcStatus = response.headers.get("grpc-status");
+                const grpcMessage = response.headers.get("grpc-message");
+
+                if (grpcStatus != null && grpcMessage != null) {
+                    const error = new GrpcServiceError(
+                        GrpcStatus._fromValue(parseInt(grpcStatus)),
+                        ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+                    );
+                    error.message = grpcMessage;
+                    callback(error, null);
+                }
+
+                const responseBuffer = await response.arrayBuffer();
+                const unaryResponse = decodeUnaryResponse(responseBuffer);
+
+                callback(null, unaryResponse);
+            } catch (error) {
+                const err = new GrpcServiceError(
+                    // retry on grpc web errors
+                    GrpcStatus._fromValue(18),
+                    ALL_WEB_NETWORK_NODES?.[this._address]?.toString(),
+                );
+                callback(err, null);
+            }
+        };
+    }
+}