@hiero-ledger/sdk 2.70.0

package/src/address_book/NodeAddressBook.js

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import NodeAddress from "./NodeAddress.js";
+import * as HieroProto from "@hashgraph/proto";
+
+/**
+ * @typedef {import("./NodeAddress.js").NodeAddressJson} NodeAddressJson
+ */
+
+/**
+ * @typedef {object} NodeAddressBookJson
+ * @property {NodeAddressJson[]} nodeAddresses
+ */
+
+/**
+ * Represents a collection of node addresses in the Hedera network.
+ *
+ * The NodeAddressBook contains information about the nodes in the Hedera network,
+ * including their network addresses, account IDs, and node IDs. This class is used
+ * to manage and access the network's node information.
+ */
+export default class NodeAddressBook {
+    /**
+     * @param {object} props
+     * @param {NodeAddress[]} [props.nodeAddresses]
+     */
+    constructor(props = {}) {
+        /**
+         * @type {NodeAddress[]}
+         */
+        this._nodeAddresses = [];
+
+        if (props.nodeAddresses != null) {
+            this.setNodeAddresses(props.nodeAddresses);
+        }
+    }
+
+    /**
+     * @returns {NodeAddress[]}
+     */
+    get nodeAddresses() {
+        return this._nodeAddresses;
+    }
+
+    /**
+     * @param {NodeAddress[]} nodeAddresses
+     * @returns {this}
+     */
+    setNodeAddresses(nodeAddresses) {
+        this._nodeAddresses = nodeAddresses;
+        return this;
+    }
+
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {NodeAddressBook}
+     */
+    static fromBytes(bytes) {
+        return NodeAddressBook._fromProtobuf(
+            HieroProto.proto.NodeAddressBook.decode(bytes),
+        );
+    }
+
+    /**
+     * @internal
+     * @param {HieroProto.proto.INodeAddressBook} nodeAddressBook
+     * @returns {NodeAddressBook}
+     */
+    static _fromProtobuf(nodeAddressBook) {
+        return new NodeAddressBook({
+            nodeAddresses:
+                nodeAddressBook.nodeAddress != null
+                    ? nodeAddressBook.nodeAddress.map((nodeAddress) =>
+                          NodeAddress._fromProtobuf(nodeAddress),
+                      )
+                    : undefined,
+        });
+    }
+
+    /**
+     * @returns {HieroProto.proto.INodeAddressBook}
+     */
+    _toProtobuf() {
+        return {
+            nodeAddress: this._nodeAddresses.map((nodeAddress) =>
+                nodeAddress._toProtobuf(),
+            ),
+        };
+    }
+
+    /**
+     * @returns {string}
+     */
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+
+    /**
+     * @returns {NodeAddressBookJson}
+     */
+    toJSON() {
+        return {
+            nodeAddresses: this._nodeAddresses.map((nodeAddress) =>
+                nodeAddress.toJSON(),
+            ),
+        };
+    }
+
+    toBytes() {
+        return HieroProto.proto.NodeAddressBook.encode(
+            this._toProtobuf(),
+        ).finish();
+    }
+}

package/src/array.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * A simple efficient function for comparing byte arrays
+ *
+ * @param {Uint8Array} array1
+ * @param {Uint8Array} array2
+ * @returns {boolean}
+ */
+export function arrayEqual(array1, array2) {
+    if (array1 === array2) {
+        return true;
+    }
+
+    if (array1.byteLength !== array2.byteLength) {
+        return false;
+    }
+
+    const view1 = new DataView(
+        array1.buffer,
+        array1.byteOffset,
+        array1.byteLength,
+    );
+    const view2 = new DataView(
+        array2.buffer,
+        array2.byteOffset,
+        array2.byteLength,
+    );
+
+    let i = array1.byteLength;
+
+    while (i--) {
+        if (view1.getUint8(i) !== view2.getUint8(i)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @param {Uint8Array} array
+ * @param {Uint8Array} arrayPrefix
+ * @returns {boolean}
+ */
+export function arrayStartsWith(array, arrayPrefix) {
+    if (array.byteLength < arrayPrefix.byteLength) {
+        return false;
+    }
+
+    let i = arrayPrefix.byteLength;
+
+    while (i--) {
+        if (array[i] !== arrayPrefix[i]) {
+            return false;
+        }
+    }
+
+    return true;
+}

package/src/base32.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// HIP-32: https://hips.hedera.com/hip/hip-32
+import { base32 } from "rfc4648";
+
+const decodeOpts = { loose: true };
+const encodeOpts = { pad: false };
+
+/**
+ * Decodes the rfc4648 base32 string into a {@link Uint8Array}. If the input string is null, returns null.
+ * @param {string} str  the base32 string.
+ * @returns {Uint8Array | ''}
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+const decode = (str) => str && base32.parse(str, decodeOpts);
+
+/**
+ * Encodes the byte array into a rfc4648 base32 string without padding. If the input is null, returns null. Note with
+ * the rfc4648 loose = true option, it allows lower case letters, padding, and auto corrects 0 -> O, 1 -> L, 8 -> B
+ * @param {Buffer|Uint8Array} data
+ * @returns {string}
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+const encode = (data) => data && base32.stringify(data, encodeOpts);
+
+export default {
+    decode,
+    encode,
+};

package/src/browser.js

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * The entry point for Browser applications
+ */
+
+export * from "./exports.js";
+
+export { default as Client } from "./client/WebClient.js";
+export { default as AddressBookQuery } from "./network/AddressBookQueryWeb.js";

package/src/channel/Channel.js

@@ -0,0 +1,340 @@
+// SPDX-License-Identifier: Apache-2.0
+
+import * as HieroProto from "@hashgraph/proto";
+import * as utf8 from "../encoding/utf8.js";
+
+const { proto } = HieroProto;
+
+/**
+ * @internal
+ * @abstract
+ */
+export default class Channel {
+    /**
+     * @protected
+     */
+    constructor() {
+        /**
+         * @protected
+         * @type {?HieroProto.proto.CryptoService}
+         */
+        this._crypto = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.SmartContractService}
+         */
+        this._smartContract = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.FileService}
+         */
+        this._file = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.ConsensusService}
+         */
+        this._consensus = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.FreezeService}
+         */
+        this._freeze = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.NetworkService}
+         */
+        this._network = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.TokenService}
+         */
+        this._token = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.ScheduleService}
+         */
+        this._schedule = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.UtilService}
+         */
+        this._util = null;
+
+        /**
+         * @protected
+         * @type {?HieroProto.proto.AddressBookService}
+         */
+        this._addressBook = null;
+    }
+
+    /**
+     * @abstract
+     * @returns {void}
+     */
+    close() {
+        throw new Error("not implemented");
+    }
+
+    /**
+     * @returns {HieroProto.proto.CryptoService}
+     */
+    get crypto() {
+        if (this._crypto != null) {
+            return this._crypto;
+        }
+
+        this._crypto = proto.CryptoService.create(
+            this._createUnaryClient("CryptoService"),
+        );
+
+        return this._crypto;
+    }
+
+    /**
+     * @returns {HieroProto.proto.SmartContractService}
+     */
+    get smartContract() {
+        if (this._smartContract != null) {
+            return this._smartContract;
+        }
+
+        this._smartContract = proto.SmartContractService.create(
+            this._createUnaryClient("SmartContractService"),
+        );
+
+        return this._smartContract;
+    }
+
+    /**
+     * @returns {HieroProto.proto.FileService}
+     */
+    get file() {
+        if (this._file != null) {
+            return this._file;
+        }
+
+        this._file = proto.FileService.create(
+            this._createUnaryClient("FileService"),
+        );
+
+        return this._file;
+    }
+
+    /**
+     * @returns {HieroProto.proto.ConsensusService}
+     */
+    get consensus() {
+        if (this._consensus != null) {
+            return this._consensus;
+        }
+
+        this._consensus = proto.ConsensusService.create(
+            this._createUnaryClient("ConsensusService"),
+        );
+
+        return this._consensus;
+    }
+
+    /**
+     * @returns {HieroProto.proto.FreezeService}
+     */
+    get freeze() {
+        if (this._freeze != null) {
+            return this._freeze;
+        }
+
+        this._freeze = proto.FreezeService.create(
+            this._createUnaryClient("FreezeService"),
+        );
+
+        return this._freeze;
+    }
+
+    /**
+     * @returns {HieroProto.proto.NetworkService}
+     */
+    get network() {
+        if (this._network != null) {
+            return this._network;
+        }
+
+        this._network = proto.NetworkService.create(
+            this._createUnaryClient("NetworkService"),
+        );
+
+        return this._network;
+    }
+
+    /**
+     * @returns {HieroProto.proto.TokenService}
+     */
+    get token() {
+        if (this._token != null) {
+            return this._token;
+        }
+
+        this._token = proto.TokenService.create(
+            this._createUnaryClient("TokenService"),
+        );
+
+        return this._token;
+    }
+
+    /**
+     * @returns {HieroProto.proto.ScheduleService}
+     */
+    get schedule() {
+        if (this._schedule != null) {
+            return this._schedule;
+        }
+
+        this._schedule = proto.ScheduleService.create(
+            this._createUnaryClient("ScheduleService"),
+        );
+
+        return this._schedule;
+    }
+
+    /**
+     * @returns {HieroProto.proto.UtilService}
+     */
+    get util() {
+        if (this._util != null) {
+            return this._util;
+        }
+
+        this._util = proto.UtilService.create(
+            this._createUnaryClient("UtilService"),
+        );
+
+        return this._util;
+    }
+
+    /**
+     * @returns {HieroProto.proto.AddressBookService}
+     */
+    get addressBook() {
+        if (this._addressBook != null) {
+            return this._addressBook;
+        }
+
+        this._addressBook = proto.AddressBookService.create(
+            this._createUnaryClient("AddressBookService"),
+        );
+
+        return this._addressBook;
+    }
+
+    /**
+     * @abstract
+     * @protected
+     * @param {string} serviceName
+     * @returns {import("protobufjs").RPCImpl}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _createUnaryClient(serviceName) {
+        throw new Error("not implemented");
+    }
+}
+
+// grpc-web+proto is a series of data or trailer frames
+
+// a frame is identified by a single byte (0 = data or 1 = trailer) followed by 4 bytes for the
+// length of the frame, followed by the frame data
+
+/**
+ * @param {Uint8Array} data
+ * @returns {ArrayBuffer}
+ */
+export function encodeRequest(data) {
+    // for our requests, we want to transfer a single data frame
+
+    const frame = new ArrayBuffer(data.byteLength + 5);
+
+    // the frame type (data) is zero and can be left default-initialized
+
+    // the length of the frame data
+    new DataView(frame, 1, 4).setUint32(0, data.length);
+
+    // copy in the frame data
+    new Uint8Array(frame, 5).set(data);
+
+    return frame;
+}
+
+/**
+ * @param {ArrayBuffer} data
+ * @param {number} byteOffset
+ * @param {number} byteLength
+ * @returns {Uint8Array}
+ */
+export function decodeUnaryResponse(
+    data,
+    byteOffset = 0,
+    byteLength = data.byteLength,
+) {
+    const dataView = new DataView(data, byteOffset, byteLength);
+    let dataOffset = 0;
+
+    /** @type {?Uint8Array} */
+    let unaryResponse = null;
+
+    // 0 = successful
+    let status = 0;
+
+    while (dataOffset < dataView.byteLength) {
+        const frameByte = dataView.getUint8(dataOffset + 0);
+        const frameType = frameByte >> 7;
+        const frameByteLength = dataView.getUint32(dataOffset + 1);
+        const frameOffset = dataOffset + 5; // offset from the start of the dataView
+        if (frameOffset + frameByteLength > dataView.byteLength) {
+            throw new Error("(BUG) unexpected frame length past the boundary");
+        }
+        const frameData = new Uint8Array(
+            data,
+            dataView.byteOffset + frameOffset,
+            frameByteLength,
+        );
+
+        if (frameType === 0) {
+            if (unaryResponse != null) {
+                throw new Error(
+                    "(BUG) unexpectedly received more than one data frame",
+                );
+            }
+
+            unaryResponse = frameData;
+        } else if (frameType === 1) {
+            const trailer = utf8.decode(frameData);
+            const [trailerName, trailerValue] = trailer.split(":");
+
+            if (trailerName === "grpc-status") {
+                status = parseInt(trailerValue);
+            } else {
+                throw new Error(`(BUG) unhandled trailer, ${trailer}`);
+            }
+        } else {
+            throw new Error(`(BUG) unexpected frame type: ${frameType}`);
+        }
+
+        dataOffset += frameByteLength + 5;
+    }
+
+    if (status !== 0) {
+        throw new Error(`(BUG) unhandled grpc-status: ${status}`);
+    }
+
+    if (unaryResponse == null) {
+        throw new Error("(BUG) unexpectedly received no response");
+    }
+
+    return unaryResponse;
+}

package/src/channel/MirrorChannel.js

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * @typedef {object} MirrorError
+ * @property {number} code
+ * @property {string} details
+ */
+
+/**
+ * @internal
+ * @abstract
+ */
+export default class MirrorChannel {
+    /**
+     * @abstract
+     * @returns {void}
+     */
+    close() {
+        throw new Error("not implemented");
+    }
+
+    /**
+     * @abstract
+     * @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(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        serviceName,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        methodName,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        requestData,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        callback,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        error,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        end,
+    ) {
+        throw new Error("not implemented");
+    }
+}