postchain-client 2.1.2 → 2.1.3

package/built/src/blockchainClient/utils.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,35 +41,61 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { Buffer } from "buffer";
-import * as logger from "../logger";
-import { SerializedTransactionFormatException, InvalidTxRidException, TxRejectedError, UnexpectedStatusError, GetBridFromChainException, } from "./errors";
-import * as gtxTool from "../gtx/gtx";
-import { BlockchainUrlUndefinedException, DirectoryNodeUrlPoolException, InvalidTransactionFormatException, MissingBlockchainIdentifierError, } from "./errors";
-import { ensureBuffer, toBuffer } from "../formatter";
-import { createClient } from "./blockchainClient";
-import { AnchoringStatus, ChainConfirmationLevel, FailoverStrategy, Method, ResponseStatus, TransactionEvent, } from "./enums";
-import { createNodeManager } from "./nodeManager";
-import { AnchoringTransactionSchema } from "./validation/anchoringTransaction";
-import { SystemChainException } from "../ICCF/error";
-import { getAnchoringClient } from "../ICCF/IccfProofTxMaterialBuilder";
-import { awaitGetAnchoringTransactionForBlockRid, calculateBlockRID } from "../ICCF/utils";
-import { isString } from "./validation/requests";
-import { encodeTransaction } from "../utils/encodeTransaction";
-import { validateMerkleHash } from "./validation/merkleHash";
-import { requestWithFailoverStrategy } from "./requestWithFailoverStrategy";
-import { MERKLE_HASH_VERSIONS } from "../utils/constants";
-import { isSuccessfulStatusCode } from "../utils/http-utils";
-export function getClientConfigFromSettings(settings) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.getUrlsFromEndpoints = exports.createEndpointObjects = exports.defaultFailoverConfig = exports.isKeyPair = exports.formatBlockInfoResponse = exports.formatTransactionInfoResponse = exports.handlePostResponsePromisified = exports.callbackPromiseBuilder = void 0;
+exports.getClientConfigFromSettings = getClientConfigFromSettings;
+exports.getMerkleHashVersionFromDapp = getMerkleHashVersionFromDapp;
+exports.validTxRid = validTxRid;
+exports.nodeDiscovery = nodeDiscovery;
+exports.getBlockchainApiUrls = getBlockchainApiUrls;
+exports.convertToRellOperation = convertToRellOperation;
+exports.getSerializedGTX = getSerializedGTX;
+exports.getGTXFromBufferOrTransactionOrOperation = getGTXFromBufferOrTransactionOrOperation;
+exports.formatRejectedTransactionFromResponse = formatRejectedTransactionFromResponse;
+exports.getSystemClient = getSystemClient;
+exports.getSystemAnchoringChain = getSystemAnchoringChain;
+exports.awaitDappConfirmation = awaitDappConfirmation;
+exports.awaitClusterAnchoringChainConfirmation = awaitClusterAnchoringChainConfirmation;
+exports.handleDappConfirmations = handleDappConfirmations;
+exports.handleSystemConfirmations = handleSystemConfirmations;
+exports.getAnchoringClientAndSystemChainRid = getAnchoringClientAndSystemChainRid;
+exports.getSystemAnchoringTransaction = getSystemAnchoringTransaction;
+exports.setStatusPolling = setStatusPolling;
+exports.setRetryTransactionPolling = setRetryTransactionPolling;
+exports.linkPromiEvents = linkPromiEvents;
+exports.handleGetResponse = handleGetResponse;
+exports.handlePostResponse = handlePostResponse;
+exports.getBlockchainRidFromIid = getBlockchainRidFromIid;
+exports.convertToPrintable = convertToPrintable;
+const buffer_1 = require("buffer");
+const logger = __importStar(require("../logger"));
+const errors_1 = require("./errors");
+const gtxTool = __importStar(require("../gtx/gtx"));
+const errors_2 = require("./errors");
+const formatter_1 = require("../formatter");
+const blockchainClient_1 = require("./blockchainClient");
+const enums_1 = require("./enums");
+const nodeManager_1 = require("./nodeManager");
+const anchoringTransaction_1 = require("./validation/anchoringTransaction");
+const error_1 = require("../ICCF/error");
+const IccfProofTxMaterialBuilder_1 = require("../ICCF/IccfProofTxMaterialBuilder");
+const utils_1 = require("../ICCF/utils");
+const requests_1 = require("./validation/requests");
+const encodeTransaction_1 = require("../utils/encodeTransaction");
+const merkleHash_1 = require("./validation/merkleHash");
+const requestWithFailoverStrategy_1 = require("./requestWithFailoverStrategy");
+const constants_1 = require("../utils/constants");
+const http_utils_1 = require("../utils/http-utils");
+function getClientConfigFromSettings(settings) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const nodeUrlPoolToUse = yield getNodeUrlsFromSettings(settings);
         if (nodeUrlPoolToUse === null || nodeUrlPoolToUse.length === 0) {
             const id = (_b = (_a = settings.blockchainRid) !== null && _a !== void 0 ? _a : settings.blockchainIid) !== null && _b !== void 0 ? _b : "Unknown";
-            throw new BlockchainUrlUndefinedException(id);
+            throw new errors_2.BlockchainUrlUndefinedException(id);
         }
-        const endpointPool = createEndpointObjects(nodeUrlPoolToUse);
-        const nodeManager = createNodeManager({
+        const endpointPool = (0, exports.createEndpointObjects)(nodeUrlPoolToUse);
+        const nodeManager = (0, nodeManager_1.createNodeManager)({
             nodeUrls: nodeUrlPoolToUse,
             useStickyNode: (_c = settings.useStickyNode) !== null && _c !== void 0 ? _c : false,
             unavailableDuration: (_d = settings.failOverConfig) === null || _d === void 0 ? void 0 : _d.unreachableDuration,
@@ -50,12 +110,12 @@ export function getClientConfigFromSettings(settings) {
                     nodeManager,
                     endpointPool,
                     chainId: settings.blockchainIid,
-                    merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
+                    merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : constants_1.MERKLE_HASH_VERSIONS.UNSET,
                     connectTimeout: settings.connectTimeout,
                     responseTimeout: settings.responseTimeout,
                 });
             }
-            throw new MissingBlockchainIdentifierError();
+            throw new errors_2.MissingBlockchainIdentifierError();
         }))();
         const directoryChainRid = yield (() => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -67,7 +127,7 @@ export function getClientConfigFromSettings(settings) {
                 nodeManager,
                 endpointPool,
                 chainId: directoryChainIid,
-                merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : MERKLE_HASH_VERSIONS.UNSET,
+                merkleHashVersion: (_a = settings.merkleHashVersion) !== null && _a !== void 0 ? _a : constants_1.MERKLE_HASH_VERSIONS.UNSET,
                 connectTimeout: settings.connectTimeout,
                 responseTimeout: settings.responseTimeout,
             });
@@ -76,50 +136,50 @@ export function getClientConfigFromSettings(settings) {
             endpointPool,
             nodeManager: nodeManager,
             blockchainRid: blockchainRidToUse,
-            merkleHashVersion: (_e = settings.merkleHashVersion) !== null && _e !== void 0 ? _e : MERKLE_HASH_VERSIONS.UNSET,
+            merkleHashVersion: (_e = settings.merkleHashVersion) !== null && _e !== void 0 ? _e : constants_1.MERKLE_HASH_VERSIONS.UNSET,
             dappStatusPolling: setStatusPolling(settings.dappStatusPolling),
             clusterAnchoringStatusPolling: setStatusPolling(settings.clusterAnchoringStatusPolling),
             systemAnchoringStatusPolling: setStatusPolling(settings.systemAnchoringStatusPolling),
             retryTransactionPolling: setRetryTransactionPolling(settings.retryTransactionPolling),
-            failoverStrategy: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.strategy) || defaultFailoverConfig.strategy,
-            attemptsPerEndpoint: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptsPerEndpoint) || defaultFailoverConfig.attemptsPerEndpoint,
-            attemptInterval: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.attemptInterval) || defaultFailoverConfig.attemptInterval,
-            unreachableDuration: ((_j = settings.failOverConfig) === null || _j === void 0 ? void 0 : _j.unreachableDuration) || defaultFailoverConfig.unreachableDuration,
+            failoverStrategy: ((_f = settings.failOverConfig) === null || _f === void 0 ? void 0 : _f.strategy) || exports.defaultFailoverConfig.strategy,
+            attemptsPerEndpoint: ((_g = settings.failOverConfig) === null || _g === void 0 ? void 0 : _g.attemptsPerEndpoint) || exports.defaultFailoverConfig.attemptsPerEndpoint,
+            attemptInterval: ((_h = settings.failOverConfig) === null || _h === void 0 ? void 0 : _h.attemptInterval) || exports.defaultFailoverConfig.attemptInterval,
+            unreachableDuration: ((_j = settings.failOverConfig) === null || _j === void 0 ? void 0 : _j.unreachableDuration) || exports.defaultFailoverConfig.unreachableDuration,
             directoryChainRid: settings.directoryChainRid || directoryChainRid,
             connectTimeout: settings.connectTimeout,
             responseTimeout: settings.responseTimeout,
         };
     });
 }
-export function getMerkleHashVersionFromDapp(config) {
+function getMerkleHashVersionFromDapp(config) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         try {
-            const response = yield requestWithFailoverStrategy(Method.GET, `/config/${config.blockchainRid}/features`, config, undefined, false, (_a = config.connectTimeout) !== null && _a !== void 0 ? _a : config.responseTimeout);
-            const validatedResponse = validateMerkleHash(response.rspBody);
+            const response = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/config/${config.blockchainRid}/features`, config, undefined, false, (_a = config.connectTimeout) !== null && _a !== void 0 ? _a : config.responseTimeout);
+            const validatedResponse = (0, merkleHash_1.validateMerkleHash)(response.rspBody);
             return validatedResponse.merkle_hash_version;
         }
         catch (error) {
             console.warn("MERKLE_HASH_WARNING: version not found or endpoint unreachable", error);
-            return MERKLE_HASH_VERSIONS.ONE;
+            return constants_1.MERKLE_HASH_VERSIONS.ONE;
         }
     });
 }
-export function validTxRid(txRID) {
+function validTxRid(txRID) {
     if (txRID.length != 32) {
-        const error = new InvalidTxRidException(txRID);
+        const error = new errors_1.InvalidTxRidException(txRID);
         logger.error(error.toString());
         return false;
     }
     return true;
 }
-export function nodeDiscovery(_a) {
+function nodeDiscovery(_a) {
     return __awaiter(this, arguments, void 0, function* ({ nodeManager, directoryEndpointPool, failOverConfig, blockchainRid, blockchainIid, connectTimeout, responseTimeout, }) {
         if (directoryEndpointPool.length === 0) {
-            throw new DirectoryNodeUrlPoolException();
+            throw new errors_2.DirectoryNodeUrlPoolException();
         }
         if (!blockchainRid && blockchainIid === undefined) {
-            throw new MissingBlockchainIdentifierError();
+            throw new errors_2.MissingBlockchainIdentifierError();
         }
         const directoryIid = 0;
         const directoryBRID = yield getBlockchainRidFromIid({
@@ -144,16 +204,16 @@ export function nodeDiscovery(_a) {
                     responseTimeout,
                 });
             }
-            throw new MissingBlockchainIdentifierError();
+            throw new errors_2.MissingBlockchainIdentifierError();
         }))();
-        const D1Client = yield createClient({
-            nodeUrlPool: getUrlsFromEndpoints(directoryEndpointPool),
+        const D1Client = yield (0, blockchainClient_1.createClient)({
+            nodeUrlPool: (0, exports.getUrlsFromEndpoints)(directoryEndpointPool),
             blockchainRid: directoryBRID,
         });
-        return yield getBlockchainApiUrls(D1Client, ensureBuffer(blockchainRidToUse));
+        return yield getBlockchainApiUrls(D1Client, (0, formatter_1.ensureBuffer)(blockchainRidToUse));
     });
 }
-export function getBlockchainApiUrls(directoryClient, blockchainRid) {
+function getBlockchainApiUrls(directoryClient, blockchainRid) {
     return __awaiter(this, void 0, void 0, function* () {
         const queryObject = {
             name: "cm_get_blockchain_api_urls",
@@ -162,7 +222,7 @@ export function getBlockchainApiUrls(directoryClient, blockchainRid) {
         return yield directoryClient.query(queryObject);
     });
 }
-export function convertToRellOperation(operations) {
+function convertToRellOperation(operations) {
     return operations.map(operation => {
         var _a;
         return {
@@ -171,20 +231,20 @@ export function convertToRellOperation(operations) {
         };
     });
 }
-export function getSerializedGTX(gtx) {
-    const gtxBytes = encodeTransaction(gtx);
-    if (!Buffer.isBuffer(gtxBytes)) {
-        throw new SerializedTransactionFormatException();
+function getSerializedGTX(gtx) {
+    const gtxBytes = (0, encodeTransaction_1.encodeTransaction)(gtx);
+    if (!buffer_1.Buffer.isBuffer(gtxBytes)) {
+        throw new errors_1.SerializedTransactionFormatException();
     }
     return gtxBytes;
 }
-export function getGTXFromBufferOrTransactionOrOperation(transaction, blockchainRid) {
-    if (Buffer.isBuffer(transaction)) {
+function getGTXFromBufferOrTransactionOrOperation(transaction, blockchainRid) {
+    if (buffer_1.Buffer.isBuffer(transaction)) {
         return gtxTool.deserialize(transaction);
     }
     else if ("operations" in transaction) {
         return {
-            blockchainRid: ensureBuffer(blockchainRid),
+            blockchainRid: (0, formatter_1.ensureBuffer)(blockchainRid),
             operations: convertToRellOperation(transaction.operations),
             signers: transaction.signers,
             signatures: [],
@@ -192,17 +252,17 @@ export function getGTXFromBufferOrTransactionOrOperation(transaction, blockchain
     }
     else if ("name" in transaction) {
         return {
-            blockchainRid: ensureBuffer(blockchainRid),
+            blockchainRid: (0, formatter_1.ensureBuffer)(blockchainRid),
             operations: convertToRellOperation([transaction]),
             signers: [],
             signatures: [],
         };
     }
     else {
-        throw new InvalidTransactionFormatException();
+        throw new errors_2.InvalidTransactionFormatException();
     }
 }
-export const callbackPromiseBuilder = (reject, resolve, callback) => {
+const callbackPromiseBuilder = (reject, resolve, callback) => {
     return (error, result) => {
         var _a;
         if (error) {
@@ -215,7 +275,8 @@ export const callbackPromiseBuilder = (reject, resolve, callback) => {
         }
     };
 };
-export const handlePostResponsePromisified = (error, statusCode, rspBody) => {
+exports.callbackPromiseBuilder = callbackPromiseBuilder;
+const handlePostResponsePromisified = (error, statusCode, rspBody) => {
     return new Promise((resolve, reject) => {
         handlePostResponse(error, statusCode, rspBody, _error => {
             if (_error) {
@@ -227,75 +288,79 @@ export const handlePostResponsePromisified = (error, statusCode, rspBody) => {
         });
     });
 };
+exports.handlePostResponsePromisified = handlePostResponsePromisified;
 function ensureArray(input) {
     if (typeof input === "string") {
         return [input];
     }
     return input;
 }
-export const formatTransactionInfoResponse = (transactionInfoResponse) => {
+const formatTransactionInfoResponse = (transactionInfoResponse) => {
     return {
-        blockRid: toBuffer(transactionInfoResponse.blockRID),
+        blockRid: (0, formatter_1.toBuffer)(transactionInfoResponse.blockRID),
         blockHeight: transactionInfoResponse.blockHeight,
-        blockHeader: toBuffer(transactionInfoResponse.blockHeader),
-        witness: toBuffer(transactionInfoResponse.witness),
+        blockHeader: (0, formatter_1.toBuffer)(transactionInfoResponse.blockHeader),
+        witness: (0, formatter_1.toBuffer)(transactionInfoResponse.witness),
         timestamp: transactionInfoResponse.timestamp,
-        txRid: toBuffer(transactionInfoResponse.txRID),
-        txHash: toBuffer(transactionInfoResponse.txHash),
-        txData: toBuffer(transactionInfoResponse.txData),
+        txRid: (0, formatter_1.toBuffer)(transactionInfoResponse.txRID),
+        txHash: (0, formatter_1.toBuffer)(transactionInfoResponse.txHash),
+        txData: (0, formatter_1.toBuffer)(transactionInfoResponse.txData),
     };
 };
-export const formatBlockInfoResponse = (blockInfoResponse) => {
+exports.formatTransactionInfoResponse = formatTransactionInfoResponse;
+const formatBlockInfoResponse = (blockInfoResponse) => {
     return {
-        rid: toBuffer(blockInfoResponse.rid),
-        prevBlockRid: toBuffer(blockInfoResponse.prevBlockRID),
-        header: toBuffer(blockInfoResponse.header),
+        rid: (0, formatter_1.toBuffer)(blockInfoResponse.rid),
+        prevBlockRid: (0, formatter_1.toBuffer)(blockInfoResponse.prevBlockRID),
+        header: (0, formatter_1.toBuffer)(blockInfoResponse.header),
         transactions: blockInfoResponse.transactions.map(formatTransaction),
         height: blockInfoResponse.height,
-        witness: toBuffer(blockInfoResponse.witness),
+        witness: (0, formatter_1.toBuffer)(blockInfoResponse.witness),
         witnesses: blockInfoResponse.witnesses.map(witness => {
-            return toBuffer(witness);
+            return (0, formatter_1.toBuffer)(witness);
         }),
         timestamp: blockInfoResponse.timestamp,
     };
 };
+exports.formatBlockInfoResponse = formatBlockInfoResponse;
 const formatTransaction = (transaction) => {
     const formattedTransaction = {
-        rid: toBuffer(transaction.rid),
-        hash: toBuffer(transaction.hash),
+        rid: (0, formatter_1.toBuffer)(transaction.rid),
+        hash: (0, formatter_1.toBuffer)(transaction.hash),
     };
     if (transaction.data !== undefined) {
-        formattedTransaction.data = toBuffer(transaction.data);
+        formattedTransaction.data = (0, formatter_1.toBuffer)(transaction.data);
     }
     return formattedTransaction;
 };
-export function formatRejectedTransactionFromResponse(rejectedTransactionResponse) {
+function formatRejectedTransactionFromResponse(rejectedTransactionResponse) {
     return {
-        txRid: toBuffer(rejectedTransactionResponse.txRID),
+        txRid: (0, formatter_1.toBuffer)(rejectedTransactionResponse.txRID),
         rejectReason: rejectedTransactionResponse.rejectReason,
         rejectTimestamp: rejectedTransactionResponse.rejectTimestamp,
     };
 }
-export const isKeyPair = (keypair) => {
+const isKeyPair = (keypair) => {
     return (typeof keypair === "object" &&
         keypair !== null &&
         "privKey" in keypair &&
         "pubKey" in keypair &&
-        keypair.privKey instanceof Buffer &&
-        keypair.pubKey instanceof Buffer);
+        keypair.privKey instanceof buffer_1.Buffer &&
+        keypair.pubKey instanceof buffer_1.Buffer);
 };
+exports.isKeyPair = isKeyPair;
 function getNodeUrlsFromSettings(settings) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         if (settings.directoryNodeUrlPool) {
             // If directoryNodeUrlPool is provided, use nodeDiscovery
-            const nodeManager = createNodeManager({
+            const nodeManager = (0, nodeManager_1.createNodeManager)({
                 nodeUrls: ensureArray(settings.directoryNodeUrlPool),
                 unavailableDuration: (_a = settings.failOverConfig) === null || _a === void 0 ? void 0 : _a.unreachableDuration,
             });
             const discoveredNodes = yield nodeDiscovery({
                 nodeManager,
-                directoryEndpointPool: createEndpointObjects(ensureArray(settings.directoryNodeUrlPool)),
+                directoryEndpointPool: (0, exports.createEndpointObjects)(ensureArray(settings.directoryNodeUrlPool)),
                 failOverConfig: settings.failOverConfig,
                 blockchainRid: settings.blockchainRid,
                 blockchainIid: settings.blockchainIid,
@@ -318,15 +383,15 @@ function getNodeUrlsFromSettings(settings) {
         }
     });
 }
-export function getSystemClient(directoryNodeUrlPool, directoryChainRid) {
+function getSystemClient(directoryNodeUrlPool, directoryChainRid) {
     return __awaiter(this, void 0, void 0, function* () {
-        return yield createClient({
+        return yield (0, blockchainClient_1.createClient)({
             directoryNodeUrlPool,
             blockchainRid: directoryChainRid,
         });
     });
 }
-export function getSystemAnchoringChain(directoryClient) {
+function getSystemAnchoringChain(directoryClient) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const queryObject = {
@@ -334,64 +399,66 @@ export function getSystemAnchoringChain(directoryClient) {
             };
             const systemAnchoringChain = yield directoryClient.query(queryObject);
             if (!systemAnchoringChain) {
-                throw new SystemChainException("Directory chain client must be provided.");
+                throw new error_1.SystemChainException("Directory chain client must be provided.");
             }
             return systemAnchoringChain;
         }
         catch (error) {
-            throw new SystemChainException(error.message);
+            throw new error_1.SystemChainException(error.message);
         }
     });
 }
-export const defaultFailoverConfig = {
-    strategy: FailoverStrategy.AbortOnError,
+exports.defaultFailoverConfig = {
+    strategy: enums_1.FailoverStrategy.AbortOnError,
     attemptsPerEndpoint: 3,
     attemptInterval: 500,
     unreachableDuration: 30000,
 };
-export const createEndpointObjects = (endpointPoolUrls) => {
+const createEndpointObjects = (endpointPoolUrls) => {
     const endpoints = endpointPoolUrls.map(endpointUrl => {
         return { url: endpointUrl, whenAvailable: 0 };
     });
     return endpoints;
 };
-export const getUrlsFromEndpoints = (endpointPool) => {
+exports.createEndpointObjects = createEndpointObjects;
+const getUrlsFromEndpoints = (endpointPool) => {
     return endpointPool.map(endpoint => endpoint.url);
 };
-export function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
+exports.getUrlsFromEndpoints = getUrlsFromEndpoints;
+function awaitDappConfirmation(txRID, dappStatusPolling, getTransactionStatus) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         let lastKnownResult = null;
         for (let i = 0; i < dappStatusPolling.count; i++) {
             lastKnownResult = yield getTransactionStatus(txRID);
-            if (lastKnownResult.status === ResponseStatus.Confirmed) {
+            if (lastKnownResult.status === enums_1.ResponseStatus.Confirmed) {
                 return lastKnownResult;
             }
-            else if (lastKnownResult.status === ResponseStatus.Rejected) {
-                throw new TxRejectedError((_a = lastKnownResult.rejectReason) !== null && _a !== void 0 ? _a : "");
+            else if (lastKnownResult.status === enums_1.ResponseStatus.Rejected) {
+                throw new errors_1.TxRejectedError((_a = lastKnownResult.rejectReason) !== null && _a !== void 0 ? _a : "");
             }
-            yield sleep(dappStatusPolling.interval);
+            yield (0, exports.sleep)(dappStatusPolling.interval);
         }
         throw new Error(`Retry count exceeded. Confirmation not received. Last transaction status: ${lastKnownResult === null || lastKnownResult === void 0 ? void 0 : lastKnownResult.status}`);
     });
 }
-export function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPolling, getClusterAnchoringTransactionConfirmation) {
+function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringStatusPolling, getClusterAnchoringTransactionConfirmation) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         let clusterAnchoringConfirmation;
         for (let i = 0; i < clusterAnchoringStatusPolling.count; i++) {
             clusterAnchoringConfirmation = yield getClusterAnchoringTransactionConfirmation(txRID);
-            const anchoringTransactionValidaiton = AnchoringTransactionSchema.safeParse(clusterAnchoringConfirmation);
+            const anchoringTransactionValidaiton = anchoringTransaction_1.AnchoringTransactionSchema.safeParse(clusterAnchoringConfirmation);
             if (anchoringTransactionValidaiton.success) {
                 return {
-                    status: AnchoringStatus.ClusterAnchored,
+                    status: enums_1.AnchoringStatus.ClusterAnchored,
                     clusterAnchoredTx: anchoringTransactionValidaiton.data,
                 };
             }
             else if (!anchoringTransactionValidaiton.success) {
-                throw new TxRejectedError((_a = AnchoringStatus.FailedAnchoring) !== null && _a !== void 0 ? _a : "");
+                throw new errors_1.TxRejectedError((_a = enums_1.AnchoringStatus.FailedAnchoring) !== null && _a !== void 0 ? _a : "");
             }
-            yield sleep(clusterAnchoringStatusPolling.interval);
+            yield (0, exports.sleep)(clusterAnchoringStatusPolling.interval);
         }
         // TS issue. This could be fixed by implementing new retry strategy
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -399,70 +466,70 @@ export function awaitClusterAnchoringChainConfirmation(txRID, clusterAnchoringSt
         return clusterAnchoringConfirmation;
     });
 }
-export function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, dappStatusPolling, getTransactionStatus, client) {
+function handleDappConfirmations(transactionRid, doStatusPolling, confirmationLevel, promiEvent, dappStatusPolling, getTransactionStatus, client) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b;
         const transactionReceipt = {
-            status: ResponseStatus.Pending,
+            status: enums_1.ResponseStatus.Pending,
             statusCode: null,
             transactionRid: transactionRid,
             node: (_a = client.config.nodeManager.lastUsedNode) === null || _a === void 0 ? void 0 : _a.url,
         };
-        promiEvent.emit(TransactionEvent.DappReceived, transactionReceipt);
-        if (doStatusPolling === false || confirmationLevel === ChainConfirmationLevel.None) {
+        promiEvent.emit(enums_1.TransactionEvent.DappReceived, transactionReceipt);
+        if (doStatusPolling === false || confirmationLevel === enums_1.ChainConfirmationLevel.None) {
             return transactionReceipt;
         }
         const dappConfirmationStatus = yield awaitDappConfirmation(transactionRid, dappStatusPolling, getTransactionStatus);
         transactionReceipt.statusCode = dappConfirmationStatus.statusCode;
         transactionReceipt.status = dappConfirmationStatus.status;
         transactionReceipt.node = (_b = client.config.nodeManager.lastUsedNode) === null || _b === void 0 ? void 0 : _b.url;
-        promiEvent.emit(TransactionEvent.DappConfirmed, transactionReceipt);
-        if (confirmationLevel === ChainConfirmationLevel.Dapp) {
+        promiEvent.emit(enums_1.TransactionEvent.DappConfirmed, transactionReceipt);
+        if (confirmationLevel === enums_1.ChainConfirmationLevel.Dapp) {
             return transactionReceipt;
         }
         return transactionReceipt;
     });
 }
-export function handleSystemConfirmations(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBrid, getClusterAnchoringTransactionConfirmation, getSystemAnchoringTransactionConfirmation) {
+function handleSystemConfirmations(transactionReceipt, confirmationLevel, promiEvent, statusPollingConfig, anchoringClient, systemAnchoringChainBrid, getClusterAnchoringTransactionConfirmation, getSystemAnchoringTransactionConfirmation) {
     return __awaiter(this, void 0, void 0, function* () {
         const clusterAnchoringChainConfirmation = yield awaitClusterAnchoringChainConfirmation(transactionReceipt.transactionRid, statusPollingConfig.clusterAnchoringStatusPolling, getClusterAnchoringTransactionConfirmation);
         transactionReceipt.status = clusterAnchoringChainConfirmation.status;
         transactionReceipt.clusterAnchoredTx = clusterAnchoringChainConfirmation.clusterAnchoredTx;
         transactionReceipt.clusterAnchoringClientBrid = anchoringClient.config.blockchainRid;
-        promiEvent.emit(TransactionEvent.ClusterAnchoringConfirmation, transactionReceipt);
-        if (confirmationLevel === ChainConfirmationLevel.ClusterAnchoring) {
+        promiEvent.emit(enums_1.TransactionEvent.ClusterAnchoringConfirmation, transactionReceipt);
+        if (confirmationLevel === enums_1.ChainConfirmationLevel.ClusterAnchoring) {
             return transactionReceipt;
         }
         const systemAnchoringConfirmation = yield getSystemAnchoringTransactionConfirmation(clusterAnchoringChainConfirmation.clusterAnchoredTx.txRid, anchoringClient, systemAnchoringChainBrid);
         if (!systemAnchoringConfirmation) {
             return transactionReceipt;
         }
-        transactionReceipt.status = AnchoringStatus.SystemAnchored;
+        transactionReceipt.status = enums_1.AnchoringStatus.SystemAnchored;
         transactionReceipt.systemAnchoredTx = systemAnchoringConfirmation;
         transactionReceipt.systemAnchoringClientBrid = systemAnchoringChainBrid;
-        promiEvent.emit(TransactionEvent.SystemAnchoringConfirmation, transactionReceipt);
-        if (confirmationLevel === ChainConfirmationLevel.SystemAnchoring) {
+        promiEvent.emit(enums_1.TransactionEvent.SystemAnchoringConfirmation, transactionReceipt);
+        if (confirmationLevel === enums_1.ChainConfirmationLevel.SystemAnchoring) {
             return transactionReceipt;
         }
         return transactionReceipt;
     });
 }
-export function getAnchoringClientAndSystemChainRid(client) {
+function getAnchoringClientAndSystemChainRid(client) {
     return __awaiter(this, void 0, void 0, function* () {
-        const directoryClient = yield getSystemClient(getUrlsFromEndpoints(client.config.endpointPool), client.config.directoryChainRid);
-        const anchoringClient = yield getAnchoringClient(directoryClient, client.config.blockchainRid);
+        const directoryClient = yield getSystemClient((0, exports.getUrlsFromEndpoints)(client.config.endpointPool), client.config.directoryChainRid);
+        const anchoringClient = yield (0, IccfProofTxMaterialBuilder_1.getAnchoringClient)(directoryClient, client.config.blockchainRid);
         const systemAnchoringChainRidBuffer = yield getSystemAnchoringChain(directoryClient);
         const systemAnchoringChainBridString = systemAnchoringChainRidBuffer.toString("hex");
         return { anchoringClient, systemAnchoringChainBridString };
     });
 }
-export function getSystemAnchoringTransaction(dappClientEndpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, systemAnchoringStatusPolling, merkleHashVersion) {
+function getSystemAnchoringTransaction(dappClientEndpointPool, anchoredTxRid, anchoringClient, systemAnchoringChainRid, systemAnchoringStatusPolling, merkleHashVersion) {
     return __awaiter(this, void 0, void 0, function* () {
-        const systemAnchoringChainClient = yield getSystemClient(getUrlsFromEndpoints(dappClientEndpointPool), systemAnchoringChainRid);
+        const systemAnchoringChainClient = yield getSystemClient((0, exports.getUrlsFromEndpoints)(dappClientEndpointPool), systemAnchoringChainRid);
         const clusterAnchoringProof = yield anchoringClient.getConfirmationProof(anchoredTxRid);
-        const clusterBlockRid = calculateBlockRID(clusterAnchoringProof, merkleHashVersion);
-        const systemAnchoringTransactionConfirmation = yield awaitGetAnchoringTransactionForBlockRid(systemAnchoringChainClient, toBuffer(anchoringClient.config.blockchainRid), clusterBlockRid, systemAnchoringStatusPolling);
-        const systemAnchoringTransactionValidation = AnchoringTransactionSchema.safeParse(systemAnchoringTransactionConfirmation);
+        const clusterBlockRid = (0, utils_1.calculateBlockRID)(clusterAnchoringProof, merkleHashVersion);
+        const systemAnchoringTransactionConfirmation = yield (0, utils_1.awaitGetAnchoringTransactionForBlockRid)(systemAnchoringChainClient, (0, formatter_1.toBuffer)(anchoringClient.config.blockchainRid), clusterBlockRid, systemAnchoringStatusPolling);
+        const systemAnchoringTransactionValidation = anchoringTransaction_1.AnchoringTransactionSchema.safeParse(systemAnchoringTransactionConfirmation);
         if (!systemAnchoringTransactionValidation.success) {
             return null;
         }
@@ -479,22 +546,22 @@ export function getSystemAnchoringTransaction(dappClientEndpointPool, anchoredTx
  * @returns - Returns a complete `StatusPolling` configuration object, with default values for any missing properties
  * of the provided partial configuration
  */
-export function setStatusPolling(statusPolling) {
+function setStatusPolling(statusPolling) {
     var _a, _b;
     return {
         interval: (_a = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.interval) !== null && _a !== void 0 ? _a : 500,
         count: (_b = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.count) !== null && _b !== void 0 ? _b : 20,
     };
 }
-export function setRetryTransactionPolling(statusPolling) {
+function setRetryTransactionPolling(statusPolling) {
     var _a, _b;
     return {
         interval: (_a = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.interval) !== null && _a !== void 0 ? _a : 500,
         count: (_b = statusPolling === null || statusPolling === void 0 ? void 0 : statusPolling.count) !== null && _b !== void 0 ? _b : 3,
     };
 }
-export function linkPromiEvents(event1, event2) {
-    const transactionEvents = Object.values(TransactionEvent).filter((event) => typeof event === "string");
+function linkPromiEvents(event1, event2) {
+    const transactionEvents = Object.values(enums_1.TransactionEvent).filter((event) => typeof event === "string");
     /* eslint-disable @typescript-eslint/no-explicit-any */
     const forwardEvent = (eventName) => (receipt) => event2.emit(eventName, receipt);
     for (const eventName of transactionEvents) {
@@ -507,7 +574,7 @@ export function linkPromiEvents(event1, event2) {
  * @param responseObject the responsebody from the server
  * @param callback the callback function to propagate the error and response back to the caller
  */
-export function handleGetResponse(error, statusCode, responseObject, callback) {
+function handleGetResponse(error, statusCode, responseObject, callback) {
     try {
         const responseObjectPrintable = convertToPrintable(responseObject);
         logger.debug(`error: ${error}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
@@ -515,7 +582,7 @@ export function handleGetResponse(error, statusCode, responseObject, callback) {
             return callback(error, null);
         }
         if (statusCode !== 200) {
-            return callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), null);
+            return callback(new errors_1.UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, responseObjectPrintable), null);
         }
         return callback(null, responseObject);
     }
@@ -530,7 +597,7 @@ export function handleGetResponse(error, statusCode, responseObject, callback) {
  * @param responseObject the responsebody from the server
  * @param callback the callback function to propagate the error and response back to the caller
  */
-export function handlePostResponse(error, statusCode, responseObject, callback) {
+function handlePostResponse(error, statusCode, responseObject, callback) {
     var _a;
     const responseObjectPrintable = convertToPrintable(responseObject);
     logger.debug(`error: ${error}, status code: ${statusCode}, response body: ${responseObjectPrintable}`);
@@ -539,7 +606,7 @@ export function handlePostResponse(error, statusCode, responseObject, callback)
             logger.error(`In client post(). ${error}`);
             callback(error, null);
         }
-        else if (!statusCode || !isSuccessfulStatusCode(statusCode)) {
+        else if (!statusCode || !(0, http_utils_1.isSuccessfulStatusCode)(statusCode)) {
             let errorMessage = `Unexpected status code from server. Code: ${statusCode}.`;
             const errorMessageInResponseBody = !!responseObject && typeof responseObject === "object" && "error" in responseObject
                 ? (_a = responseObject.error) === null || _a === void 0 ? void 0 : _a.toString()
@@ -548,7 +615,7 @@ export function handlePostResponse(error, statusCode, responseObject, callback)
                 errorMessage += ` Message: ${responseObjectPrintable}.`;
             }
             logger.error(errorMessage);
-            callback(new UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, errorMessageInResponseBody || responseObjectPrintable), responseObject);
+            callback(new errors_1.UnexpectedStatusError(statusCode !== null && statusCode !== void 0 ? statusCode : 400, errorMessageInResponseBody || responseObjectPrintable), responseObject);
         }
         else {
             logger.info(`Calling responseCallback with responseObject: ${responseObjectPrintable}`);
@@ -559,10 +626,10 @@ export function handlePostResponse(error, statusCode, responseObject, callback)
         logger.error(`client.handlePostResponse(): Failed to call callback function ${error}`);
     }
 }
-export function getBlockchainRidFromIid(_a) {
+function getBlockchainRidFromIid(_a) {
     return __awaiter(this, arguments, void 0, function* ({ endpointPool, chainId, failOverConfig = {}, nodeManager, connectTimeout, responseTimeout, }) {
         var _b;
-        const mergedFailOverConfig = Object.assign(Object.assign({}, defaultFailoverConfig), failOverConfig);
+        const mergedFailOverConfig = Object.assign(Object.assign({}, exports.defaultFailoverConfig), failOverConfig);
         const config = {
             endpointPool,
             nodeManager,
@@ -574,26 +641,27 @@ export function getBlockchainRidFromIid(_a) {
             attemptsPerEndpoint: mergedFailOverConfig.attemptsPerEndpoint,
             attemptInterval: mergedFailOverConfig.attemptInterval,
             unreachableDuration: mergedFailOverConfig.unreachableDuration,
-            merkleHashVersion: MERKLE_HASH_VERSIONS.UNSET,
+            merkleHashVersion: constants_1.MERKLE_HASH_VERSIONS.UNSET,
             connectTimeout,
             responseTimeout,
         };
-        const { error, statusCode, rspBody } = yield requestWithFailoverStrategy(Method.GET, `/brid/iid_${chainId}`, config, undefined, false, (_b = config.connectTimeout) !== null && _b !== void 0 ? _b : config.responseTimeout);
-        const blockchainRid = isString(rspBody);
+        const { error, statusCode, rspBody } = yield (0, requestWithFailoverStrategy_1.requestWithFailoverStrategy)(enums_1.Method.GET, `/brid/iid_${chainId}`, config, undefined, false, (_b = config.connectTimeout) !== null && _b !== void 0 ? _b : config.responseTimeout);
+        const blockchainRid = (0, requests_1.isString)(rspBody);
         if (!blockchainRid) {
             throw error;
         }
         if (error) {
-            throw new GetBridFromChainException(chainId, error.message);
+            throw new errors_1.GetBridFromChainException(chainId, error.message);
         }
         else if (statusCode !== 200) {
-            throw new GetBridFromChainException(chainId, blockchainRid);
+            throw new errors_1.GetBridFromChainException(chainId, blockchainRid);
         }
         return blockchainRid;
     });
 }
-export const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-export function convertToPrintable(responseObject) {
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+exports.sleep = sleep;
+function convertToPrintable(responseObject) {
     if (typeof responseObject === "bigint") {
         return `${responseObject}n`;
     }