postchain-client 2.1.2 → 2.1.3

package/built/src/blockchainClient/blockchainClient.js

@@ -1,3 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -7,30 +41,35 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { randomBytes } from "crypto";
-import cloneDeep from "lodash/cloneDeep";
-import { getBlockAnchoringTransaction } from "../ICCF/IccfProofTxMaterialBuilder";
-import * as logger from "../logger";
-import { toBuffer, toString, toQueryObjectGTV, ensureString, ensureBuffer } from "../formatter";
-import { decodeValue, encodeValue } from "../gtx/serialization";
-import * as gtxTool from "../gtx/gtx";
-import { callbackPromiseBuilder, formatBlockInfoResponse, formatTransactionInfoResponse, getClientConfigFromSettings, getGTXFromBufferOrTransactionOrOperation, getSerializedGTX, handlePostResponsePromisified, handleSystemConfirmations, isKeyPair, getAnchoringClientAndSystemChainRid, getSystemAnchoringTransaction, linkPromiEvents, handleGetResponse, handlePostResponse, handleDappConfirmations, getMerkleHashVersionFromDapp, formatRejectedTransactionFromResponse, sleep, } from "./utils";
-import { Web3PromiEvent } from "../promiEvent/promiEvents";
-import { NumberOfSignersAndSignaturesException } from "../gtx/errors";
-import { ResponseStatus, ChainConfirmationLevel, AnchoringStatus, TransactionEvent, Method, } from "./enums";
-import { isBlockIdentifierValid } from "./validation/blockIdentifier";
-import { isNetworkSettingValid } from "./validation/networkSettings";
-import { isSignMethodValid } from "./validation/signMethod";
-import { isTxRidValid } from "./validation/txRid";
-import { AnchoringTransactionSchema } from "./validation/anchoringTransaction";
-import { isBlockInfoResponse, isBlockInfoResponseArray, isRawGtv, isRejectedTransactionResponseArray, isTransaction, isTransactionConfirmationProof, isTransactionInfoResponse, isTransactionInfoResponseArray, isTransactionsCount, } from "./validation/requests";
-import { awaitGetAnchoringTransactionForBlockRid } from "../ICCF/utils";
-import { requestWithFailoverStrategy } from "./requestWithFailoverStrategy";
-import { validateTransactionStatusReponse } from "./validation/transactionStatusReponse";
-export function createClient(settings) {
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+const crypto_1 = require("crypto");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+const IccfProofTxMaterialBuilder_1 = require("../ICCF/IccfProofTxMaterialBuilder");
+const logger = __importStar(require("../logger"));
+const formatter_1 = require("../formatter");
+const serialization_1 = require("../gtx/serialization");
+const gtxTool = __importStar(require("../gtx/gtx"));
+const utils_1 = require("./utils");
+const promiEvents_1 = require("../promiEvent/promiEvents");
+const errors_1 = require("../gtx/errors");
+const enums_1 = require("./enums");
+const blockIdentifier_1 = require("./validation/blockIdentifier");
+const networkSettings_1 = require("./validation/networkSettings");
+const signMethod_1 = require("./validation/signMethod");
+const txRid_1 = require("./validation/txRid");
+const anchoringTransaction_1 = require("./validation/anchoringTransaction");
+const requests_1 = require("./validation/requests");
+const utils_2 = require("../ICCF/utils");
+const requestWithFailoverStrategy_1 = require("./requestWithFailoverStrategy");
+const transactionStatusReponse_1 = require("./validation/transactionStatusReponse");
+function createClient(settings) {
     return __awaiter(this, void 0, void 0, function* () {
-        isNetworkSettingValid(settings, { throwOnError: true });
-        const config = yield getClientConfigFromSettings(settings);
+        (0, networkSettings_1.isNetworkSettingValid)(settings, { throwOnError: true });
+        const config = yield (0, utils_1.getClientConfigFromSettings)(settings);
         config.merkleHashVersion = yield getMerkleHashVersion(settings);
         return {
             config,
@@ -45,21 +84,21 @@ export function createClient(settings) {
                         _name = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.name;
                         _args = nameOrQueryObject === null || nameOrQueryObject === void 0 ? void 0 : nameOrQueryObject.args;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `query_gtv/${config.blockchainRid}`, config, encodeValue(toQueryObjectGTV(_name, _args)));
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.POST, `query_gtv/${config.blockchainRid}`, config, (0, serialization_1.encodeValue)((0, formatter_1.toQueryObjectGTV)(_name, _args)));
                     return new Promise((resolve, reject) => {
-                        handlePostResponse(error, statusCode, isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handlePostResponse)(error, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             signTransaction(transaction, signMethod, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    logger.debug(`Signing transaction with ${!isKeyPair(signMethod) ? "signature provider containing " : ""}pubKey: ${toString(signMethod.pubKey)}`);
-                    const gtx = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
+                    logger.debug(`Signing transaction with ${!(0, utils_1.isKeyPair)(signMethod) ? "signature provider containing " : ""}pubKey: ${(0, formatter_1.toString)(signMethod.pubKey)}`);
+                    const gtx = (0, utils_1.getGTXFromBufferOrTransactionOrOperation)(transaction, config.blockchainRid);
                     try {
-                        const signedTx = yield (isKeyPair(signMethod)
+                        const signedTx = yield ((0, utils_1.isKeyPair)(signMethod)
                             ? gtxTool.sign(gtx, signMethod.privKey, config.merkleHashVersion, signMethod.pubKey)
                             : gtxTool.sign(gtx, signMethod, config.merkleHashVersion));
-                        const gtxBytes = getSerializedGTX(signedTx);
+                        const gtxBytes = (0, utils_1.getSerializedGTX)(signedTx);
                         if (typeof callback === "function") {
                             callback(null, gtxBytes);
                         }
@@ -74,35 +113,35 @@ export function createClient(settings) {
                     }
                 });
             },
-            sendTransactionWithRetries(transaction, callback, confirmationLevel = ChainConfirmationLevel.Dapp) {
+            sendTransactionWithRetries(transaction, callback, confirmationLevel = enums_1.ChainConfirmationLevel.Dapp) {
                 const client = this;
                 function sendOnce() {
                     return client.sendTransaction(transaction, true, callback, confirmationLevel);
                 }
-                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                const promiEvent = new promiEvents_1.Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                     let error = null;
                     // await sleep(1000);
                     for (let i = 0; i < config.retryTransactionPolling.count; i++) {
                         logger.info(`sendTransactionWithRetries attempt ${i + 1} of ${config.retryTransactionPolling.count}`);
                         const tmpPromiEvent = sendOnce()
-                            .on(TransactionEvent.ClusterAnchoringConfirmation, receipt => {
-                            promiEvent.emit(TransactionEvent.ClusterAnchoringConfirmation, receipt);
+                            .on(enums_1.TransactionEvent.ClusterAnchoringConfirmation, receipt => {
+                            promiEvent.emit(enums_1.TransactionEvent.ClusterAnchoringConfirmation, receipt);
                         })
-                            .on(TransactionEvent.SystemAnchoringConfirmation, receipt => {
-                            promiEvent.emit(TransactionEvent.SystemAnchoringConfirmation, receipt);
+                            .on(enums_1.TransactionEvent.SystemAnchoringConfirmation, receipt => {
+                            promiEvent.emit(enums_1.TransactionEvent.SystemAnchoringConfirmation, receipt);
                         })
-                            .on(TransactionEvent.DappReceived, receipt => {
-                            promiEvent.emit(TransactionEvent.DappReceived, receipt);
+                            .on(enums_1.TransactionEvent.DappReceived, receipt => {
+                            promiEvent.emit(enums_1.TransactionEvent.DappReceived, receipt);
                         })
-                            .on(TransactionEvent.Signed, receipt => {
-                            promiEvent.emit(TransactionEvent.Signed, receipt);
+                            .on(enums_1.TransactionEvent.Signed, receipt => {
+                            promiEvent.emit(enums_1.TransactionEvent.Signed, receipt);
                         })
-                            .on(TransactionEvent.DappConfirmed, receipt => {
-                            promiEvent.emit(TransactionEvent.DappConfirmed, receipt);
+                            .on(enums_1.TransactionEvent.DappConfirmed, receipt => {
+                            promiEvent.emit(enums_1.TransactionEvent.DappConfirmed, receipt);
                         })
                             .catch(tmpError => {
                             logger.warning(`sendTransactionWithRetries error on attempt ${i + 1} of ${config.retryTransactionPolling.count}: ${tmpError}`);
-                            promiEvent.emit(TransactionEvent.Rejected, tmpError);
+                            promiEvent.emit(enums_1.TransactionEvent.Rejected, tmpError);
                             error = tmpError;
                         });
                         const tmpReceipt = yield tmpPromiEvent;
@@ -110,28 +149,28 @@ export function createClient(settings) {
                             resolve(tmpReceipt);
                             return;
                         }
-                        yield sleep(config.retryTransactionPolling.interval);
+                        yield (0, utils_1.sleep)(config.retryTransactionPolling.interval);
                     }
                     reject(error);
                 }));
                 return promiEvent;
             },
-            sendTransaction(transaction, doStatusPolling = true, callback, confirmationLevel = ChainConfirmationLevel.Dapp) {
-                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            sendTransaction(transaction, doStatusPolling = true, callback, confirmationLevel = enums_1.ChainConfirmationLevel.Dapp) {
+                const promiEvent = new promiEvents_1.Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                     var _a, _b;
                     try {
-                        const gtx = getGTXFromBufferOrTransactionOrOperation(transaction, config.blockchainRid);
+                        const gtx = (0, utils_1.getGTXFromBufferOrTransactionOrOperation)(transaction, config.blockchainRid);
                         if (gtx.signers.length !== ((_a = gtx.signatures) === null || _a === void 0 ? void 0 : _a.length)) {
-                            reject(new NumberOfSignersAndSignaturesException());
+                            reject(new errors_1.NumberOfSignersAndSignaturesException());
                         }
-                        const gtxBytes = getSerializedGTX(gtx);
-                        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.POST, `tx/${config.blockchainRid}`, config, gtxBytes);
+                        const gtxBytes = (0, utils_1.getSerializedGTX)(gtx);
+                        const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.POST, `tx/${config.blockchainRid}`, config, gtxBytes);
                         const transactionRid = gtxTool.getDigestToSign(gtx, config.merkleHashVersion);
                         try {
-                            yield handlePostResponsePromisified(error, statusCode, isRawGtv(rspBody));
+                            yield (0, utils_1.handlePostResponsePromisified)(error, statusCode, (0, requests_1.isRawGtv)(rspBody));
                             if (typeof callback === "function") {
                                 callback(null, {
-                                    status: ResponseStatus.Waiting,
+                                    status: enums_1.ResponseStatus.Waiting,
                                     statusCode,
                                     transactionRid: transactionRid,
                                     node: (_b = config.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url,
@@ -151,14 +190,14 @@ export function createClient(settings) {
                             systemAnchoringStatusPolling: client.config.systemAnchoringStatusPolling,
                         };
                         const stickyNodeClient = yield createStickyNodeClient(client); //to avoid false rejections by oblivious nodes
-                        let transactionReceipt = yield handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => stickyNodeClient.getTransactionStatus(transactionRid, callback), stickyNodeClient);
-                        if (confirmationLevel === ChainConfirmationLevel.None ||
-                            confirmationLevel === ChainConfirmationLevel.Dapp) {
+                        let transactionReceipt = yield (0, utils_1.handleDappConfirmations)(transactionRid, doStatusPolling, confirmationLevel, promiEvent, statusPollingConfig.dappStatusPolling, () => stickyNodeClient.getTransactionStatus(transactionRid, callback), stickyNodeClient);
+                        if (confirmationLevel === enums_1.ChainConfirmationLevel.None ||
+                            confirmationLevel === enums_1.ChainConfirmationLevel.Dapp) {
                             resolve(transactionReceipt);
                             return;
                         }
-                        const { anchoringClient, systemAnchoringChainBridString } = yield getAnchoringClientAndSystemChainRid(client);
-                        transactionReceipt = yield handleSystemConfirmations(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBridString, () => stickyNodeClient.getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient, callback), anchoredTxRid => stickyNodeClient.getSystemAnchoringTransactionConfirmation(anchoredTxRid, anchoringClient, systemAnchoringChainBridString, callback));
+                        const { anchoringClient, systemAnchoringChainBridString } = yield (0, utils_1.getAnchoringClientAndSystemChainRid)(client);
+                        transactionReceipt = yield (0, utils_1.handleSystemConfirmations)(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBridString, () => stickyNodeClient.getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient, callback), anchoredTxRid => stickyNodeClient.getSystemAnchoringTransactionConfirmation(anchoredTxRid, anchoringClient, systemAnchoringChainBridString, callback));
                         resolve(transactionReceipt);
                     }
                     catch (error) {
@@ -168,9 +207,9 @@ export function createClient(settings) {
                 }));
                 return promiEvent;
             },
-            signAndSendUniqueTransaction(transactionOrOperation, signMethod, doStatusPolling = true, callback, confirmationLevel = ChainConfirmationLevel.Dapp) {
-                isSignMethodValid(signMethod, { throwOnError: true });
-                const promiEvent = new Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            signAndSendUniqueTransaction(transactionOrOperation, signMethod, doStatusPolling = true, callback, confirmationLevel = enums_1.ChainConfirmationLevel.Dapp) {
+                (0, signMethod_1.isSignMethodValid)(signMethod, { throwOnError: true });
+                const promiEvent = new promiEvents_1.Web3PromiEvent((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                     const client = this;
                     const transaction = "name" in transactionOrOperation
                         ? {
@@ -184,9 +223,9 @@ export function createClient(settings) {
                     const transactionWithNop = hasNop ? transaction : client.addNop(transaction);
                     try {
                         const signedTx = yield client.signTransaction(transactionWithNop, signMethod);
-                        promiEvent.emit(TransactionEvent.Signed, signedTx);
+                        promiEvent.emit(enums_1.TransactionEvent.Signed, signedTx);
                         const sendTransactionPromiEvent = client.sendTransaction(signedTx, doStatusPolling, callback, confirmationLevel);
-                        linkPromiEvents(sendTransactionPromiEvent, promiEvent);
+                        (0, utils_1.linkPromiEvents)(sendTransactionPromiEvent, promiEvent);
                         resolve(yield sendTransactionPromiEvent);
                     }
                     catch (error) {
@@ -198,31 +237,31 @@ export function createClient(settings) {
             getTransaction(transactionRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(transactionRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(transactionRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${ensureString(transactionRid)}`, config);
-                    const transaction = isTransaction(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `tx/${config.blockchainRid}/${(0, formatter_1.ensureString)(transactionRid)}`, config);
+                    const transaction = (0, requests_1.isTransaction)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && transaction ? toBuffer(transaction.tx) : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 && transaction ? (0, formatter_1.toBuffer)(transaction.tx) : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getTransactionStatus(transactionRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(transactionRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(transactionRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${transactionRid.toString("hex")}/status`, config);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `tx/${config.blockchainRid}/${transactionRid.toString("hex")}/status`, config);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(rspBody), callbackPromiseBuilder(reject, result => resolve(validateTransactionStatusReponse({
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, result => resolve((0, transactionStatusReponse_1.validateTransactionStatusReponse)({
                             statusCode,
                             result,
                         })), callback));
@@ -230,10 +269,10 @@ export function createClient(settings) {
                 });
             },
             addNop(transaction) {
-                const _transaction = cloneDeep(transaction);
+                const _transaction = (0, cloneDeep_1.default)(transaction);
                 const noOperation = {
                     name: "nop",
-                    args: [randomBytes(32)],
+                    args: [(0, crypto_1.randomBytes)(32)],
                 };
                 _transaction.operations = [..._transaction.operations, noOperation];
                 return _transaction;
@@ -243,54 +282,54 @@ export function createClient(settings) {
                     const beforeTimeQueryParam = beforeTime ? `&before-time=${beforeTime.getTime()}` : "";
                     const afterTimeQueryParam = afterTime ? `&after-time=${afterTime.getTime()}` : "";
                     const signerQueryParam = signerPubKey ? `&signer=${signerPubKey}` : "";
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}?limit=${limit}${beforeTimeQueryParam}${afterTimeQueryParam}${signerQueryParam}`, config);
-                    const transactionsInfoResponseArray = isTransactionInfoResponseArray(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `transactions/${config.blockchainRid}?limit=${limit}${beforeTimeQueryParam}${afterTimeQueryParam}${signerQueryParam}`, config);
+                    const transactionsInfoResponseArray = (0, requests_1.isTransactionInfoResponseArray)(rspBody);
                     const body = statusCode === 200 && transactionsInfoResponseArray
-                        ? transactionsInfoResponseArray.map(formatTransactionInfoResponse)
+                        ? transactionsInfoResponseArray.map(utils_1.formatTransactionInfoResponse)
                         : rspBody;
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(body), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(body), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getTransactionInfo(transactionRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(transactionRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(transactionRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}/${ensureString(transactionRid)}`, config);
-                    const transactionInfoResponse = isTransactionInfoResponse(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `transactions/${config.blockchainRid}/${(0, formatter_1.ensureString)(transactionRid)}`, config);
+                    const transactionInfoResponse = (0, requests_1.isTransactionInfoResponse)(rspBody);
                     const body = statusCode === 200 && transactionInfoResponse
-                        ? formatTransactionInfoResponse(transactionInfoResponse)
+                        ? (0, utils_1.formatTransactionInfoResponse)(transactionInfoResponse)
                         : rspBody;
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(body), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(body), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getAnchoringStatusForBlockRid(blockRid, anchoringClient, systemAnchoringChainRid) {
                 return __awaiter(this, void 0, void 0, function* () {
                     const client = this;
-                    const result = { status: AnchoringStatus.NotAnchored };
-                    const clusterAnchoredTx = yield awaitGetAnchoringTransactionForBlockRid(anchoringClient, ensureBuffer(client.config.blockchainRid), ensureBuffer(blockRid), config.clusterAnchoringStatusPolling);
+                    const result = { status: enums_1.AnchoringStatus.NotAnchored };
+                    const clusterAnchoredTx = yield (0, utils_2.awaitGetAnchoringTransactionForBlockRid)(anchoringClient, (0, formatter_1.ensureBuffer)(client.config.blockchainRid), (0, formatter_1.ensureBuffer)(blockRid), config.clusterAnchoringStatusPolling);
                     if (!clusterAnchoredTx) {
                         return result;
                     }
-                    const anchoringTransactionValidation = AnchoringTransactionSchema.safeParse(clusterAnchoredTx);
+                    const anchoringTransactionValidation = anchoringTransaction_1.AnchoringTransactionSchema.safeParse(clusterAnchoredTx);
                     if (!anchoringTransactionValidation.success) {
                         return result;
                     }
-                    result.status = AnchoringStatus.ClusterAnchored;
+                    result.status = enums_1.AnchoringStatus.ClusterAnchored;
                     result.clusterAnchoredTx = anchoringTransactionValidation.data;
-                    const systemAnchoredTransaction = yield getSystemAnchoringTransaction(config.endpointPool, anchoringTransactionValidation.data.txRid, anchoringClient, systemAnchoringChainRid, config.systemAnchoringStatusPolling, config.merkleHashVersion);
+                    const systemAnchoredTransaction = yield (0, utils_1.getSystemAnchoringTransaction)(config.endpointPool, anchoringTransactionValidation.data.txRid, anchoringClient, systemAnchoringChainRid, config.systemAnchoringStatusPolling, config.merkleHashVersion);
                     if (!systemAnchoredTransaction) {
                         return result;
                     }
-                    result.status = AnchoringStatus.SystemAnchored;
+                    result.status = enums_1.AnchoringStatus.SystemAnchored;
                     result.systemAnchoredTx = systemAnchoredTransaction;
                     return result;
                 });
@@ -304,30 +343,30 @@ export function createClient(settings) {
                         const response = {
                             status: dappConfirmation.status,
                             statusCode: dappConfirmation.statusCode,
-                            transactionRid: ensureBuffer(transactionRid),
+                            transactionRid: (0, formatter_1.ensureBuffer)(transactionRid),
                             node: (_a = client.config.nodeManager.lastUsedNode) === null || _a === void 0 ? void 0 : _a.url,
                         };
-                        if (dappConfirmation.status === ResponseStatus.Waiting) {
+                        if (dappConfirmation.status === enums_1.ResponseStatus.Waiting) {
                             return response;
                         }
                         let clusterAnchoringResult = null;
-                        if (dappConfirmation.status === ResponseStatus.Confirmed) {
-                            const { anchoringClient, systemAnchoringChainBridString } = yield getAnchoringClientAndSystemChainRid(client);
+                        if (dappConfirmation.status === enums_1.ResponseStatus.Confirmed) {
+                            const { anchoringClient, systemAnchoringChainBridString } = yield (0, utils_1.getAnchoringClientAndSystemChainRid)(client);
                             clusterAnchoringResult = yield client.getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient);
-                            if (clusterAnchoringResult === AnchoringStatus.NotAnchored || !clusterAnchoringResult) {
+                            if (clusterAnchoringResult === enums_1.AnchoringStatus.NotAnchored || !clusterAnchoringResult) {
                                 return response;
                             }
-                            if (clusterAnchoringResult === AnchoringStatus.FailedAnchoring) {
-                                response.status = AnchoringStatus.FailedAnchoring;
+                            if (clusterAnchoringResult === enums_1.AnchoringStatus.FailedAnchoring) {
+                                response.status = enums_1.AnchoringStatus.FailedAnchoring;
                                 response.statusCode = 400;
                                 return response;
                             }
-                            const anchoringTransactionValidation = AnchoringTransactionSchema.safeParse(clusterAnchoringResult);
+                            const anchoringTransactionValidation = anchoringTransaction_1.AnchoringTransactionSchema.safeParse(clusterAnchoringResult);
                             if (!anchoringTransactionValidation.success) {
                                 return response;
                             }
                             if (anchoringTransactionValidation.success) {
-                                response.status = AnchoringStatus.ClusterAnchored;
+                                response.status = enums_1.AnchoringStatus.ClusterAnchored;
                                 response.statusCode = 200;
                                 response.clusterAnchoredTx = anchoringTransactionValidation.data;
                                 response.clusterAnchoringClientBrid = anchoringClient.config.blockchainRid;
@@ -335,7 +374,7 @@ export function createClient(settings) {
                                 if (!systemAnchoringResult) {
                                     return response;
                                 }
-                                response.status = AnchoringStatus.SystemAnchored;
+                                response.status = enums_1.AnchoringStatus.SystemAnchored;
                                 response.systemAnchoredTx = systemAnchoringResult;
                                 response.systemAnchoringClientBrid = systemAnchoringChainBridString;
                                 return response;
@@ -351,36 +390,36 @@ export function createClient(settings) {
             },
             getTransactionCount(callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `transactions/${config.blockchainRid}/count`, config, undefined, true);
-                    const transactionsCount = isTransactionsCount(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `transactions/${config.blockchainRid}/count`, config, undefined, true);
+                    const transactionsCount = (0, requests_1.isTransactionsCount)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 ? transactionsCount === null || transactionsCount === void 0 ? void 0 : transactionsCount.transactionsCount : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 ? transactionsCount === null || transactionsCount === void 0 ? void 0 : transactionsCount.transactionsCount : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
-            getBlockInfo(blockIdentifier_1) {
+            getBlockInfo(blockIdentifier_2) {
                 return __awaiter(this, arguments, void 0, function* (blockIdentifier, txs = false, callback) {
-                    isBlockIdentifierValid(blockIdentifier, { throwOnError: true });
+                    (0, blockIdentifier_1.isBlockIdentifierValid)(blockIdentifier, { throwOnError: true });
                     const queryString = typeof blockIdentifier === "string" ? blockIdentifier : `height/${blockIdentifier}`;
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}/${queryString}?txs=${txs}`, config);
-                    const blockInfoResponse = isBlockInfoResponse(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `blocks/${config.blockchainRid}/${queryString}?txs=${txs}`, config);
+                    const blockInfoResponse = (0, requests_1.isBlockInfoResponse)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && blockInfoResponse !== null && blockInfoResponse
-                            ? formatBlockInfoResponse(blockInfoResponse)
-                            : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 && blockInfoResponse !== null && blockInfoResponse
+                            ? (0, utils_1.formatBlockInfoResponse)(blockInfoResponse)
+                            : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getLatestBlock() {
                 return __awaiter(this, arguments, void 0, function* (txs = false, callback) {
                     const shouldIncludeFullTransaction = txs ? `&txs=${txs}` : "";
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, config, undefined, true);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `blocks/${config.blockchainRid}?limit=1${shouldIncludeFullTransaction}`, config, undefined, true);
                     const indexOfLatestBlock = 0;
-                    const blockInfoResponseArray = isBlockInfoResponseArray(rspBody);
+                    const blockInfoResponseArray = (0, requests_1.isBlockInfoResponseArray)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && blockInfoResponseArray !== null && blockInfoResponseArray
-                            ? formatBlockInfoResponse(blockInfoResponseArray[indexOfLatestBlock])
-                            : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 && blockInfoResponseArray !== null && blockInfoResponseArray
+                            ? (0, utils_1.formatBlockInfoResponse)(blockInfoResponseArray[indexOfLatestBlock])
+                            : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
@@ -401,12 +440,12 @@ export function createClient(settings) {
                             searchParams.append(key, value.toString());
                         }
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `blocks/${config.blockchainRid}?${searchParams}`, config);
-                    const blockInfoResponseArray = isBlockInfoResponseArray(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `blocks/${config.blockchainRid}?${searchParams}`, config);
+                    const blockInfoResponseArray = (0, requests_1.isBlockInfoResponseArray)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 && blockInfoResponseArray
-                            ? blockInfoResponseArray.map(formatBlockInfoResponse)
-                            : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 && blockInfoResponseArray
+                            ? blockInfoResponseArray.map(utils_1.formatBlockInfoResponse)
+                            : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
@@ -441,24 +480,24 @@ export function createClient(settings) {
             getConfirmationProof(txRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(txRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(txRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `tx/${config.blockchainRid}/${ensureString(txRid)}/confirmationProof`, config);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `tx/${config.blockchainRid}/${(0, formatter_1.ensureString)(txRid)}/confirmationProof`, config);
                     const confirmationProof = {
                         merkleProofTree: "",
                         txIndex: 0,
                     };
                     if (statusCode === 200) {
                         try {
-                            const transactionConfirmationProof = isTransactionConfirmationProof(rspBody);
+                            const transactionConfirmationProof = (0, requests_1.isTransactionConfirmationProof)(rspBody);
                             if (!transactionConfirmationProof) {
                                 throw error;
                             }
-                            const decodedProof = decodeValue(toBuffer(transactionConfirmationProof.proof));
+                            const decodedProof = (0, serialization_1.decodeValue)((0, formatter_1.toBuffer)(transactionConfirmationProof.proof));
                             confirmationProof.txIndex = decodedProof.txIndex;
                             confirmationProof.hash = decodedProof.hash;
                             confirmationProof.blockHeader = decodedProof.blockHeader;
@@ -473,14 +512,14 @@ export function createClient(settings) {
                         }
                     }
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, statusCode === 200 ? confirmationProof : isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, statusCode === 200 ? confirmationProof : (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getClusterAnchoringTransactionConfirmation(transactionRid, anchoringClient, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(transactionRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(transactionRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
@@ -494,48 +533,48 @@ export function createClient(settings) {
                         }
                         catch (error) {
                             callback === null || callback === void 0 ? void 0 : callback(error, null);
-                            return AnchoringStatus.NotAnchored;
+                            return enums_1.AnchoringStatus.NotAnchored;
                         }
-                        const anchoringTransaction = yield getBlockAnchoringTransaction(client, anchoringClient, transactionRid, confirmationProof);
+                        const anchoringTransaction = yield (0, IccfProofTxMaterialBuilder_1.getBlockAnchoringTransaction)(client, anchoringClient, transactionRid, confirmationProof);
                         if (!anchoringTransaction)
-                            return AnchoringStatus.NotAnchored;
+                            return enums_1.AnchoringStatus.NotAnchored;
                         return anchoringTransaction;
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
-                        return AnchoringStatus.FailedAnchoring;
+                        return enums_1.AnchoringStatus.FailedAnchoring;
                     }
                 });
             },
             getSystemAnchoringTransactionConfirmation(anchoredTxRid, anchoringClient, systemAnchoringChainRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
                     try {
-                        isTxRidValid(anchoredTxRid, { throwOnError: true });
+                        (0, txRid_1.isTxRidValid)(anchoredTxRid, { throwOnError: true });
                     }
                     catch (error) {
                         callback === null || callback === void 0 ? void 0 : callback(error, null);
                         throw error;
                     }
-                    const systemAnchoringTransactionTransaction = yield getSystemAnchoringTransaction(config.endpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, config.systemAnchoringStatusPolling, config.merkleHashVersion);
+                    const systemAnchoringTransactionTransaction = yield (0, utils_1.getSystemAnchoringTransaction)(config.endpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, config.systemAnchoringStatusPolling, config.merkleHashVersion);
                     return systemAnchoringTransactionTransaction;
                 });
             },
             getWaitingTransactions(blockchainRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/tx/${ensureString(blockchainRid)}/waiting`, config);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/tx/${(0, formatter_1.ensureString)(blockchainRid)}/waiting`, config);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
             getWaitingTransaction(blockchainRid, txRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody, transactionTimestamp } = yield requestWithFailoverStrategy(Method.GET, `/tx/${ensureString(blockchainRid)}/waiting/${ensureString(txRid)}`, config);
-                    const transaction = isTransaction(rspBody);
-                    const result = transaction ? toBuffer(transaction.tx) : isRawGtv(rspBody);
+                    const { error, statusCode, rspBody, transactionTimestamp } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/tx/${(0, formatter_1.ensureString)(blockchainRid)}/waiting/${(0, formatter_1.ensureString)(txRid)}`, config);
+                    const transaction = (0, requests_1.isTransaction)(rspBody);
+                    const result = transaction ? (0, formatter_1.toBuffer)(transaction.tx) : (0, requests_1.isRawGtv)(rspBody);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, result, callbackPromiseBuilder(reject, txData => resolve({
-                            txData: isRawGtv(txData),
+                        (0, utils_1.handleGetResponse)(error, statusCode, result, (0, utils_1.callbackPromiseBuilder)(reject, txData => resolve({
+                            txData: (0, requests_1.isRawGtv)(txData),
                             transactionTimestamp: Number(transactionTimestamp),
                         }), callback));
                     });
@@ -543,13 +582,13 @@ export function createClient(settings) {
             },
             getRejectedTransactions(blockchainRid, callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/tx/${ensureString(blockchainRid)}/rejected`, config);
-                    const rejectedTransactionsArray = isRejectedTransactionResponseArray(rspBody);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/tx/${(0, formatter_1.ensureString)(blockchainRid)}/rejected`, config);
+                    const rejectedTransactionsArray = (0, requests_1.isRejectedTransactionResponseArray)(rspBody);
                     const validResponseBody = statusCode === 200 && rejectedTransactionsArray
-                        ? rejectedTransactionsArray.map(rejectedTransaction => formatRejectedTransactionFromResponse(rejectedTransaction))
+                        ? rejectedTransactionsArray.map(rejectedTransaction => (0, utils_1.formatRejectedTransactionFromResponse)(rejectedTransaction))
                         : rspBody;
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(validResponseBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(validResponseBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
@@ -559,9 +598,9 @@ export function createClient(settings) {
              */
             getAppStructure(callback) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/query/${config.blockchainRid}?type=rell.get_app_structure`, config);
+                    const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/query/${config.blockchainRid}?type=rell.get_app_structure`, config);
                     return new Promise((resolve, reject) => {
-                        handleGetResponse(error, statusCode, isRawGtv(rspBody), callbackPromiseBuilder(reject, resolve, callback));
+                        (0, utils_1.handleGetResponse)(error, statusCode, (0, requests_1.isRawGtv)(rspBody), (0, utils_1.callbackPromiseBuilder)(reject, resolve, callback));
                     });
                 });
             },
@@ -573,7 +612,7 @@ export function createClient(settings) {
                     merkleHashVersion = settings.merkleHashVersion;
                 }
                 else {
-                    merkleHashVersion = yield getMerkleHashVersionFromDapp(config);
+                    merkleHashVersion = yield (0, utils_1.getMerkleHashVersionFromDapp)(config);
                 }
                 return merkleHashVersion;
             });